diff --git a/README.md b/README.md
index 2253bda3..861c072c 100644
--- a/README.md
+++ b/README.md
@@ -49,9 +49,10 @@ Build LLVM & Neura
  - Test:
 ```sh
  $ cd ../test
+ # a test with detailed middle output
  $ ../build/tools/mlir-neura-opt/mlir-neura-opt --debug test.mlir
 
  # Or test with lit:
- $ /workspace/llvm-project/build/bin/llvm-lit . -v
+ $ /workspace/llvm-project/build/bin/llvm-lit test.mlir -v
 ```
 
diff --git a/include/NeuraDialect/NeuraOps.td b/include/NeuraDialect/NeuraOps.td
index c044769a..21ad4366 100644
--- a/include/NeuraDialect/NeuraOps.td
+++ b/include/NeuraDialect/NeuraOps.td
@@ -6,10 +6,7 @@ include "NeuraDialect/NeuraDialect.td"
 // Defines basic scalar operations.
 
 def Neura_ConstantOp : Op<NeuraDialect, "constant"> {
-  let arguments = (ins 
-    AnyAttr:$value,
-    OptionalAttr<BoolAttr>:$predicate  // Add optional predicate attribute
-  );
+  let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType:$result);
   // let assemblyFormat = "attr-dict `:` type($result)";
 }
@@ -20,7 +17,7 @@ def Neura_AddOp : Op<NeuraDialect, "add"> {
   let opName = "add";
   let arguments = (ins AnyType:$lhs, Optional<AnyType>:$rhs);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -28,7 +25,7 @@ def Neura_SubOp : Op<NeuraDialect, "sub"> {
   let summary = "Integer substraction operation";
   let arguments = (ins AnyType:$lhs, Optional<AnyType>:$rhs);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -37,7 +34,7 @@ def Neura_MulOp : Op<NeuraDialect, "mul"> {
   let opName = "mul";
   let arguments = (ins AnyType:$lhs, Optional<AnyType>:$rhs);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -45,7 +42,7 @@ def Neura_DivOp : Op<NeuraDialect, "div"> {
   let summary = "Integer division operation";
   let arguments = (ins AnyType:$lhs, Optional<AnyType>:$rhs);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -54,7 +51,7 @@ def Neura_RemOp : Op<NeuraDialect, "rem">{
   let description = [{
     Performs an integer remainder operation, computing the result of
     a % b, where % is the remainder operator.
-    
+
     Example:
       %result = neura.rem %a, %b : i32
   }];
@@ -87,9 +84,9 @@ def Neura_FSubOp: Op<NeuraDialect, "fsub"> {
 def Neura_FMulOp : Op<NeuraDialect, "fmul"> {
   let summary = "Floating multiplication operation";
   let opName = "fmul";
-  let arguments = (ins AnyType:$lhs, AnyType:$rhs, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$lhs, AnyType:$rhs);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   // let traits = [SameOperandsAndResultElementType];
 }
 
@@ -103,9 +100,9 @@ def Neura_FDivOp : Op<NeuraDialect, "fdiv"> {
 // Defines a bitwise OR operation.
 def Neura_OrOp : Op<NeuraDialect, "or"> {
   let summary = "Bitwise OR operation";
-  let arguments = (ins AnySignlessInteger:$lhs, AnySignlessInteger:$rhs, Optional<AnyType>:$predicate);
+  let arguments = (ins AnySignlessInteger:$lhs, AnySignlessInteger:$rhs);
   let results = (outs AnySignlessInteger:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -134,20 +131,20 @@ def Neura_FCmpOp : Op<NeuraDialect, "fcmp"> {
 
 // Defines a load operation.
 def Neura_LoadOp : Op<NeuraDialect, "load"> {
-  let arguments = (ins AnyType:$addr, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$addr);
   let results = (outs AnyType:$value);
-  // let assemblyFormat = "$addr `,` $predicate attr-dict `:` type($value)";
+  // let assemblyFormat = "$addr `,` attr-dict `:` type($value)";
 }
 
 // Defines a store operation.
 def Neura_StoreOp : Op<NeuraDialect, "store"> {
-  let arguments = (ins AnyType:$value, AnyType:$addr, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$value, AnyType:$addr);
   let results = (outs);
-  // let assemblyFormat = "$value `,` $addr `,` $predicate attr-dict";
+  // let assemblyFormat = "$value `,` $addr `,` attr-dict";
 }
 
 // Defines a load operation with integrated address calculation.
-def Neura_LoadIndexedOp: Op<NeuraDialect, "load_indexed", [AttrSizedOperandSegments]>{
+def Neura_LoadIndexedOp: Op<NeuraDialect, "load_indexed">{
   let summary = "Load with integrated address calculation for multi-dimensional arrays";
   let description = [{
     Calculates the address using the base address and indices.
@@ -155,13 +152,13 @@ def Neura_LoadIndexedOp: Op<NeuraDialect, "load_indexed", [AttrSizedOperandSegme
     Example:
       %value = neura.load_indexed %base [%arg1, %arg2] : f32
   }];
-  let arguments = (ins AnyType:$base, Variadic<AnyType>:$indices, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$base, Variadic<AnyType>:$indices);
   let results = (outs AnyType:$result);
-  let assemblyFormat = "$base `[` $indices `:` type($indices) `]` type($base) ($predicate^ `:` type($predicate))? attr-dict `:` type($result)";
+  let assemblyFormat = "$base `[` $indices `:` type($indices) `]` type($base) attr-dict `:` type($result)";
 }
 
 //Defines a store operation with integrated address calculation.
-def Neura_StoreIndexedOp: Op<NeuraDialect, "store_indexed", [AttrSizedOperandSegments]> {
+def Neura_StoreIndexedOp: Op<NeuraDialect, "store_indexed"> {
   let summary = "Store with integrated address calculation for multi-dimensional arrays";
   let description = [{
     Calculates the address using the base address and indices.
@@ -169,9 +166,9 @@ def Neura_StoreIndexedOp: Op<NeuraDialect, "store_indexed", [AttrSizedOperandSeg
     Example:
       neura.store_indexed %value, %base [%arg1, %arg2] : f32
   }];
-  let arguments = (ins AnyType:$value, AnyType:$base, Variadic<AnyType>:$indices, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$value, AnyType:$base, Variadic<AnyType>:$indices);
   let results = (outs);
-  let assemblyFormat = "$value `to` $base `[` $indices `:` type($indices) `]` type($base) ($predicate^ `:` type($predicate))? attr-dict `:` type($value)";
+  let assemblyFormat = "$value `to` $base `[` $indices `:` type($indices) `]` type($base) attr-dict `:` type($value)";
 }
 
 // Defines a pointer computation operation.
@@ -185,11 +182,10 @@ def Neura_GEP : Op<NeuraDialect, "gep"> {
 // Defines a conditional branch operation.
 def Neura_CondBr : Op<NeuraDialect, "cond_br", [Terminator, AttrSizedOperandSegments]> {
   let arguments = (ins AnyType:$condition,
-                   Optional<AnyType>:$predicate,
                    Variadic<AnyType>:$trueArgs,
                    Variadic<AnyType>:$falseArgs);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
-  let assemblyFormat = "$condition `:` type($condition) ($predicate^ `:` type($predicate))? `then` ($trueArgs^ `:` type($trueArgs))? `to` $trueDest `else` ($falseArgs^ `:` type($falseArgs))? `to` $falseDest attr-dict";
+  let assemblyFormat = "$condition `:` type($condition) `then` ($trueArgs^ `:` type($trueArgs))? `to` $trueDest `else` ($falseArgs^ `:` type($falseArgs))? `to` $falseDest attr-dict";
 }
 
 // Defines an unconditional branch operation.
@@ -214,15 +210,15 @@ def Neura_NotOp : Op<NeuraDialect, "not"> {
 // Defines a return operation.
 def Neura_ReturnOp : Op<NeuraDialect, "return", [Terminator]> {
   let arguments = (ins Variadic<AnyType>:$values);
-  // let assemblyFormat = "($values^)? `,` $predicate attr-dict";
+  // let assemblyFormat = "($values^)? `,` attr-dict";
 }
 
 // Defines a cast operation for type conversion.
 def Neura_CastOp : Op<NeuraDialect, "cast">{
   let summary = "Generic type conversion operation";
-  let arguments = (ins AnyType:$input, StrAttr:$cast_type, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$input, StrAttr:$cast_type);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$input type($input) `->` type($output) `,` $predicate attr-dict";
+  // let assemblyFormat = "$input type($input) `->` type($output) `,` attr-dict";
 }
 
 // Defines an alloca operation for memory allocation.
@@ -231,11 +227,11 @@ def Neura_AllocaOp : Op<NeuraDialect, "alloca"> {
   let description = [{
     Allocates memory on the stack, similar to llvm.alloca.
     Takes a predicated size value and returns a pointer to the allocated memory.
-    
+
     Example:
       %ptr = neura.alloca %size : !neura.data<i32, i1> -> !llvm.ptr
   }];
-  
+
   let arguments = (ins Optional<AnyType>:$size);
   let results = (outs AnyType:$result);
   let assemblyFormat = "($size^ `:` type($size))? attr-dict `->` type($result)";
@@ -247,11 +243,11 @@ def Neura_SExtOp : Op<NeuraDialect, "sext"> {
   let description = [{
     Sign extends a value from a smaller integer type to a larger integer type.
     Similar to llvm.sext, but works with predicated values.
-    
+
     Example:
       %extended = neura.sext %value : !neura.data<i8, i1> -> !neura.data<i32, i1>
   }];
-  
+
   let arguments = (ins AnyType:$value);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$value attr-dict `:` type($value) `->` type($result)";
@@ -263,11 +259,11 @@ def Neura_ZExtOp : Op<NeuraDialect, "zext"> {
   let description = [{
     Zero extends a value from a smaller integer type to a larger integer type.
     Similar to llvm.zext, but works with predicated values.
-    
+
     Example:
       %extended = neura.zext %value : !neura.data<i8, i1> -> !neura.data<i32, i1>
   }];
-  
+
   let arguments = (ins AnyType:$value);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$value attr-dict `:` type($value) `->` type($result)";
@@ -286,7 +282,7 @@ def Neura_ShlOp : Op<NeuraDialect, "shl"> {
   let arguments = (ins AnyType:$value, Optional<AnyType>:$shiftAmount);
   let results = (outs AnyType:$result);
 }
- 
+
 // ----------------------------------------------------
 // Defines vector operations.
 
@@ -303,9 +299,9 @@ def VectorOfAnyFloat :
 def Neura_VFMulOp : Op<NeuraDialect, "vfmul"> {
   let summary = "Vector floating multiplication operation";
   let opName = "vfmul";
-  let arguments = (ins VectorOfAnyFloat:$lhs, VectorOfAnyFloat:$rhs, Optional<AnyType>:$predicate);
+  let arguments = (ins VectorOfAnyFloat:$lhs, VectorOfAnyFloat:$rhs);
   let results = (outs VectorOfAnyFloat:$result);
-  // let assemblyFormat = "$lhs `,` $rhs `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$lhs `,` $rhs `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -314,17 +310,17 @@ def Neura_VFMulOp : Op<NeuraDialect, "vfmul"> {
 
 def Neura_FAddFAddOp : Op<NeuraDialect, "fadd_fadd"> {
   let summary = "Fused fadd(fadd(a, b), c)";
-  let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$a `,` $b `,` $c `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$a `,` $b `,` $c `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
 def Neura_FMulFAddOp : Op<NeuraDialect, "fmul_fadd"> {
   let summary = "Fused fadd(fmul(a, b), c)";
-  let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c, Optional<AnyType>:$predicate);
+  let arguments = (ins AnyType:$a, AnyType:$b, AnyType:$c);
   let results = (outs AnyType:$result);
-  // let assemblyFormat = "$a `,` $b `,` $c `,` $predicate attr-dict `:` type($result)";
+  // let assemblyFormat = "$a `,` $b `,` $c `,` attr-dict `:` type($result)";
   let traits = [SameOperandsAndResultElementType];
 }
 
@@ -346,7 +342,7 @@ def Neura_PhiOp : Op<NeuraDialect, "phi"> {
   let description = [{
     Merges values from different control paths in dataflow form.
     Used with reserve and ctrl_mov to represent control flow.
-    
+
     Example:
       %v = neura.reserve : f32           // Create placeholder
       %result = neura.phi %init, %v      // Merge initial and loop-carried values
@@ -385,7 +381,7 @@ def Neura_ReserveOp : Op<NeuraDialect, "reserve"> {
   let description = [{
     Creates a placeholder value that will be connected via ctrl_mov.
     Used to represent control flow dependencies in dataflow form.
-    
+
     Example:
       %v = neura.reserve : f32      // Create placeholder
       %result = neura.phi %init, %v // Use in phi node
@@ -402,7 +398,7 @@ def Neura_GrantPredicateOp : Op<NeuraDialect, "grant_predicate"> {
   let description = [{
     Takes a predicated value and a predicate (i1), producing a new predicated
     value whose predicate bit is set to the given condition.
-    
+
     Example:
       %g = neura.grant_predicate %val, %pred : !neura.data<f32, i1>, !neura.data<i1, i1> -> !neura.data<f32, i1>
   }];
@@ -418,13 +414,13 @@ def Neura_GrantOnceOp : Op<NeuraDialect, "grant_once"> {
   let description = [{
     Either grants a value a one-time predicate, or creates a constant value with a one-time predicate. The resulting value is considered valid
     only during its first activation. Used to initialize recurrence cycles.
-    
+
     Example:
       %v = neura.grant_once %init : !neura.data<f32, i1> -> !neura.data<f32, i1>
       %c = neura.grant_once <{value = 42 : i64}> : !neura.data<i64, i1>
   }];
 
-  let arguments = (ins 
+  let arguments = (ins
   Optional<AnyType>:$value,
   OptionalAttr<AnyAttr>:$constant_value);
   let results = (outs AnyType:$result);
@@ -437,12 +433,12 @@ def Neura_GrantAlwaysOp : Op<NeuraDialect, "grant_always"> {
   let description = [{
     Grants a value always-valid predicate: the resulting value is considered valid
     during the entire application lifetime.
-    
+
     Example:
       %v = neura.grant_always %init : !neura.data<f32, i1> -> !neura.data<f32, i1>
   }];
 
-  let arguments = (ins 
+  let arguments = (ins
   Optional<AnyType>:$value,
   OptionalAttr<AnyAttr>:$constant_value);
   let results = (outs AnyType:$result);
@@ -458,13 +454,13 @@ def Neura_LoopControlOp : Op<NeuraDialect, "loop_control">{
   let description = [{
     Controls loop execution with minimal recurrence cycle length (1).
     Takes the current index and produces the next index and validity predicate.
-    
+
     This operation combines comparison and increment logic into a single operation,
     enabling efficient loop execution on dataflow architectures with modulo scheduling.
-    
+
     The first iteration automatically uses the start value because the reserve operation's
     predicate bit is initially 0, while the start value's predicate bit is 1.
-    
+
     Example:
       // Shows loop control that calculates next index and validity in one step.
       %next_idx, %loop_valid = neura.loop_control(
diff --git a/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp b/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp
index bdc0160f..dc6f4532 100644
--- a/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp
+++ b/lib/Conversion/ArithToNeura/ArithToNeuraPass.cpp
@@ -36,9 +36,8 @@ struct ArithConstantToNeuraConstant
     // Converts arith constant to Neura constant.
     Type result_type = op.getType();
     Attribute value = op.getValue();
-    // Optional predicate parameter can be null.
-    rewriter.replaceOpWithNewOp<neura::ConstantOp>(op, result_type, value,
-                                                   rewriter.getBoolAttr(true));
+
+    rewriter.replaceOpWithNewOp<neura::ConstantOp>(op, result_type, value);
     return success();
   }
 };
@@ -97,7 +96,7 @@ struct ArithSubFToNeuraFSub : public OpRewritePattern<mlir::arith::SubFOp> {
     Value rhs = op.getRhs();
     Type result_type = op.getType();
 
-    // Optional predicate: default to null.
+
     rewriter.replaceOpWithNewOp<neura::FSubOp>(op, result_type, lhs, rhs);
     return success();
   }
@@ -127,9 +126,8 @@ struct ArithMulFToNeuraFMul : public OpRewritePattern<mlir::arith::MulFOp> {
     Value rhs = op.getRhs();
     Type result_type = op.getType();
 
-    // Optional predicate: default to null.
-    rewriter.replaceOpWithNewOp<neura::FMulOp>(op, result_type, lhs, rhs,
-                                               nullptr);
+
+    rewriter.replaceOpWithNewOp<neura::FMulOp>(op, result_type, lhs, rhs);
     return success();
   }
 };
@@ -142,7 +140,6 @@ struct ArithDivSIToNeuraDiv : public OpRewritePattern<mlir::arith::DivSIOp> {
     Value rhs = op.getRhs();
     Type result_type = op.getType();
     // Converts arith DivSIOp to Neura DivOp.
-    // Optional predicate: default to null.
     rewriter.replaceOpWithNewOp<neura::DivOp>(op, result_type, lhs, rhs);
     return success();
   }
@@ -173,8 +170,9 @@ struct ArithRemSIToNeuraOp : public OpRewritePattern<mlir::arith::RemSIOp> {
     Type result_type = op.getType();
     Location loc = op.getLoc();
     // Converts arith RemSIOp to basic Neura Op.
-    // Optional predicate: default to null.
-    Value div = rewriter.create<neura::DivOp>(loc, result_type, lhs, rhs);
+
+    Value div =
+        rewriter.create<neura::DivOp>(loc, result_type, lhs, rhs);
     Value mul = rewriter.create<neura::MulOp>(loc, result_type, rhs, div);
     Value rem = rewriter.create<neura::SubOp>(loc, result_type, lhs, mul);
 
@@ -229,7 +227,7 @@ struct ArithCmpiToNeuraICmp : public OpRewritePattern<mlir::arith::CmpIOp> {
     }
 
     // Converts arith CmpIOp to Neura ICmpOp.
-    // Optional predicate: default to null.
+
     rewriter.replaceOpWithNewOp<neura::ICmpOp>(
         op, result_type, lhs, rhs, rewriter.getStringAttr(cmp_type));
     return success();
@@ -262,9 +260,9 @@ struct ArithExtUIToNeuraCast : public OpRewritePattern<mlir::arith::ExtUIOp> {
     Type result_type = op.getType();
 
     // Converts arith ExtUIOp to Neura cast operation.
-    // Optional predicate: default to null.
+
     rewriter.replaceOpWithNewOp<neura::CastOp>(
-        op, result_type, input, rewriter.getStringAttr("extui"), nullptr);
+        op, result_type, input, rewriter.getStringAttr("extui"));
     return success();
   }
 };
@@ -278,9 +276,9 @@ struct ArithExtfToNeuraCast : public OpRewritePattern<mlir::arith::ExtFOp> {
     Type result_type = op.getType();
 
     // Converts arith ExtFOp to Neura cast operation.
-    // Optional predicate: default to null.
+
     rewriter.replaceOpWithNewOp<neura::CastOp>(
-        op, result_type, input, rewriter.getStringAttr("extf"), nullptr);
+        op, result_type, input, rewriter.getStringAttr("extf"));
     return success();
   }
 };
@@ -307,9 +305,9 @@ struct ArithIndexCastToNeuraCast
     }
 
     // Converts arith IndexCastOp to Neura cast operation.
-    // Optional predicate: default to null.
+
     rewriter.replaceOpWithNewOp<neura::CastOp>(
-        op, result_type, input, rewriter.getStringAttr(cast_string), nullptr);
+        op, result_type, input, rewriter.getStringAttr(cast_string));
     return success();
   }
 };
diff --git a/lib/Conversion/BuiltinToNeura/BuiltinToNeuraPass.cpp b/lib/Conversion/BuiltinToNeura/BuiltinToNeuraPass.cpp
index 688ab27d..78550c77 100644
--- a/lib/Conversion/BuiltinToNeura/BuiltinToNeuraPass.cpp
+++ b/lib/Conversion/BuiltinToNeura/BuiltinToNeuraPass.cpp
@@ -35,9 +35,8 @@ struct BuiltinUnrealizedConversionCastToNeuraCast
         return rewriter.notifyMatchFailure(op, "unsupported cast");
       }
 
-      // Optional predicate: default to null.
       rewriter.replaceOpWithNewOp<neura::CastOp>(
-          op, result_type, input, rewriter.getStringAttr(cast_type), nullptr);
+          op, result_type, input, rewriter.getStringAttr(cast_type));
       return success();
     }
     return failure();
diff --git a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp
index 79c501ef..94f51676 100644
--- a/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp
+++ b/lib/Conversion/LlvmToNeura/LlvmToNeuraPass.cpp
@@ -52,7 +52,6 @@ struct LlvmFAddToNeuraFAdd : public OpRewritePattern<mlir::LLVM::FAddOp> {
     if (!mlir::isa<FloatType>(result_type))
       return failure();
 
-    // Sets optional predicate: default to 'none'.
     rewriter.replaceOpWithNewOp<neura::FAddOp>(op, result_type, lhs, rhs);
     return success();
   }
@@ -72,7 +71,6 @@ struct LlvmFSubToNeuraFSub : public OpRewritePattern<mlir::LLVM::FSubOp> {
       return failure();
     }
 
-    // Sets optional predicate: default to 'none'.
     rewriter.replaceOpWithNewOp<neura::FSubOp>(op, result_type, lhs, rhs);
     return success();
   }
@@ -84,7 +82,7 @@ struct LlvmOrToNeuraOr : public OpRewritePattern<mlir::LLVM::OrOp> {
   LogicalResult matchAndRewrite(mlir::LLVM::OrOp op,
                                 PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<neura::OrOp>(op, op.getType(), op.getLhs(),
-                                             op.getRhs(), Value());
+                                             op.getRhs());
     return success();
   }
 };
@@ -102,8 +100,7 @@ struct LlvmFMulToNeuraFMul : public OpRewritePattern<mlir::LLVM::FMulOp> {
     if (!mlir::isa<FloatType>(result_type))
       return failure();
 
-    rewriter.replaceOpWithNewOp<neura::FMulOp>(op, result_type, lhs, rhs,
-                                               Value());
+    rewriter.replaceOpWithNewOp<neura::FMulOp>(op, result_type, lhs, rhs);
     return success();
   }
 };
@@ -151,8 +148,7 @@ struct LlvmVFMulToNeuraVFMul : public OpRewritePattern<mlir::LLVM::FMulOp> {
     if (!vecTy || !mlir::isa<FloatType>(vecTy.getElementType()))
       return failure();
 
-    rewriter.replaceOpWithNewOp<neura::VFMulOp>(op, result_type, lhs, rhs,
-                                                Value());
+    rewriter.replaceOpWithNewOp<neura::VFMulOp>(op, result_type, lhs, rhs);
     return success();
   }
 };
@@ -207,7 +203,6 @@ struct LlvmGEPToNeuraGEP : public OpRewritePattern<mlir::LLVM::GEPOp> {
         OperationState state(op.getLoc(),
                              neura::ConstantOp::getOperationName());
         state.addAttribute("value", intAttr);
-        state.addAttribute("predicate", rewriter.getBoolAttr(true));
         state.addTypes(rewriter.getIndexType());
         Value cst = rewriter.create(state)->getResult(0);
         indexValues.push_back(cst);
@@ -229,7 +224,7 @@ struct LlvmLoadToNeuraLoad : public OpRewritePattern<mlir::LLVM::LoadOp> {
                                 PatternRewriter &rewriter) const override {
     Value ptr = op.getAddr(); // getPointer() is deprecated.
     Type resultType = op.getResult().getType();
-    rewriter.replaceOpWithNewOp<neura::LoadOp>(op, resultType, ptr, Value());
+    rewriter.replaceOpWithNewOp<neura::LoadOp>(op, resultType, ptr);
     return success();
   }
 };
@@ -241,7 +236,7 @@ struct LlvmStoreToNeuraStore : public OpRewritePattern<mlir::LLVM::StoreOp> {
                                 PatternRewriter &rewriter) const override {
     Value value = op.getValue();
     Value addr = op.getAddr(); // getPointer() is deprecated
-    rewriter.replaceOpWithNewOp<neura::StoreOp>(op, value, addr, Value());
+    rewriter.replaceOpWithNewOp<neura::StoreOp>(op, value, addr);
     return success();
   }
 };
@@ -262,7 +257,6 @@ struct LlvmCondBrToNeuraCondBr : public OpRewritePattern<LLVM::CondBrOp> {
     auto newOp = rewriter.create<neura::CondBr>(
         op.getLoc(),       // Location
         op.getCondition(), // Condition
-        Value(),           // Optional predicate, default to 'none'
         trueOperands,      // True destination operands
         falseOperands,     // False destination operands
         trueDest,          // True destination block
@@ -322,7 +316,6 @@ struct LlvmConstantToNeuraConstant : public OpRewritePattern<LLVM::ConstantOp> {
     // Creates operation state manually.
     OperationState state(op.getLoc(), neura::ConstantOp::getOperationName());
     state.addAttribute("value", attr);
-    state.addAttribute("predicate", rewriter.getBoolAttr(true));
     state.addTypes(op.getType());
 
     // Creates the operation and replaces.
@@ -436,9 +429,11 @@ struct LlvmFuncToNeuraFunc : public OpRewritePattern<LLVM::LLVMFuncOp> {
     }
     state.addAttributes(attrs);
 
+
     // Adds the function body region.
     state.addRegion();
 
+
     auto newFunc = cast<func::FuncOp>(rewriter.create(state));
 
     // Moves the function body.
@@ -477,6 +472,7 @@ struct LlvmCallToFuncCall : public OpRewritePattern<LLVM::CallOp> {
     // Gets the result types from the function signature.
     auto resultTypes = funcOp.getFunctionType().getResults();
 
+
     // Converts the call to func.call.
     auto newCall = rewriter.create<func::CallOp>(
         op.getLoc(), resultTypes, callee.value(), op.getArgOperands());
diff --git a/lib/Conversion/MemRefToNeura/MemRefToNeuraPass.cpp b/lib/Conversion/MemRefToNeura/MemRefToNeuraPass.cpp
index b039a525..c7157120 100644
--- a/lib/Conversion/MemRefToNeura/MemRefToNeuraPass.cpp
+++ b/lib/Conversion/MemRefToNeura/MemRefToNeuraPass.cpp
@@ -24,9 +24,8 @@ struct MemRefLoadLowering : public OpRewritePattern<memref::LoadOp> {
     Type result_type = load_op.getType();
     Value memref = load_op.getMemRef();
     ValueRange indices = load_op.getIndices();
-    // Optiional predicate: default to null
     rewriter.replaceOpWithNewOp<neura::LoadIndexedOp>(load_op, result_type,
-                                                      memref, indices, nullptr);
+                                                      memref, indices);
     return success();
   }
 };
@@ -40,9 +39,8 @@ struct MemRefStoreLowering : public OpRewritePattern<memref::StoreOp> {
     Value value = store_op.getValueToStore();
     Value memref = store_op.getMemRef();
     ValueRange indices = store_op.getIndices();
-    // Optional predicate: default to null.
     rewriter.replaceOpWithNewOp<neura::StoreIndexedOp>(store_op, value, memref,
-                                                       indices, nullptr);
+                                                       indices);
     return success();
   }
 };
diff --git a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp
index 5b2bda27..663802f1 100644
--- a/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp
+++ b/lib/NeuraDialect/Transforms/CanonicalizeLiveInPass.cpp
@@ -31,11 +31,9 @@ LogicalResult promoteFunctionArgsToConstants(Region &region) {
 
   // Creates a constant operation for each function argument.
   for (auto [idx, arg] : llvm::enumerate(args)) {
-    // For constant operation, the default predicate is true.
     auto const_op = builder.create<neura::ConstantOp>(
         arg.getLoc(), arg.getType(),
-        builder.getStringAttr("\%arg" + std::to_string(idx)),
-        builder.getBoolAttr(true));
+        builder.getStringAttr("\%arg" + std::to_string(idx)));
     arg.replaceAllUsesWith(const_op.getResult());
   }
 
@@ -288,7 +286,7 @@ LogicalResult promoteLiveInValuesToBlockArgs(Region &region) {
         if (needs_update) {
           OpBuilder builder(cond_br_op);
           builder.create<neura::CondBr>(
-              cond_br_op.getLoc(), cond_br_op.getCondition(), nullptr,
+              cond_br_op.getLoc(), cond_br_op.getCondition(),
               true_operands, false_operands, cond_br_op.getTrueDest(),
               cond_br_op.getFalseDest());
           cond_br_op.erase();
diff --git a/lib/NeuraDialect/Transforms/FusePatternPass.cpp b/lib/NeuraDialect/Transforms/FusePatternPass.cpp
index 168ff7ff..a3ddb349 100644
--- a/lib/NeuraDialect/Transforms/FusePatternPass.cpp
+++ b/lib/NeuraDialect/Transforms/FusePatternPass.cpp
@@ -48,7 +48,7 @@ struct FuseFAddFAddPattern : public OpRewritePattern<neura::FAddOp> {
     Type type = second.getType();
 
     auto fused = rewriter.create<neura::FAddFAddOp>(
-        loc, type, first.getLhs(), first.getRhs(), tail, Value());
+        loc, type, first.getLhs(), first.getRhs(), tail);
 
     rewriter.replaceOp(second, fused.getResult());
     rewriter.eraseOp(first);
@@ -91,7 +91,7 @@ struct FuseFMulFAddPattern : public OpRewritePattern<neura::FAddOp> {
     Type type = add.getType();
 
     auto fused = rewriter.create<neura::FMulFAddOp>(
-        loc, type, fmul.getLhs(), fmul.getRhs(), other, Value());
+        loc, type, fmul.getLhs(), fmul.getRhs(), other);
 
     rewriter.replaceOp(add, fused.getResult());
     rewriter.eraseOp(fmul);
diff --git a/lib/NeuraDialect/Transforms/Optimizations/HwSpecificOpt/FuseLoopControlPass.cpp b/lib/NeuraDialect/Transforms/Optimizations/HwSpecificOpt/FuseLoopControlPass.cpp
index 43a73bf0..c52eb4ce 100644
--- a/lib/NeuraDialect/Transforms/Optimizations/HwSpecificOpt/FuseLoopControlPass.cpp
+++ b/lib/NeuraDialect/Transforms/Optimizations/HwSpecificOpt/FuseLoopControlPass.cpp
@@ -320,8 +320,7 @@ Value createConstantPredicate(PatternRewriter &rewriter, Location loc,
   auto predicated_type = rewriter.getType<neura::PredicatedValue>(
       rewriter.getI1Type(), rewriter.getI1Type());
   return rewriter.create<neura::ConstantOp>(loc, predicated_type,
-                                            rewriter.getBoolAttr(value),
-                                            rewriter.getBoolAttr(true));
+                                            rewriter.getBoolAttr(value));
 }
 
 Operation *findDefiningOp(Value value) {
diff --git a/lib/NeuraDialect/Transforms/PromoteFuncArgToConstPass.cpp b/lib/NeuraDialect/Transforms/PromoteFuncArgToConstPass.cpp
index aced6fc4..f7bdef5a 100644
--- a/lib/NeuraDialect/Transforms/PromoteFuncArgToConstPass.cpp
+++ b/lib/NeuraDialect/Transforms/PromoteFuncArgToConstPass.cpp
@@ -32,11 +32,10 @@ LogicalResult promoteFunctionArgsToConstants(Region &region) {
 
   // Creates a constant operation for each function argument.
   for (auto [idx, arg] : llvm::enumerate(args)) {
-    // For constant operation, the default predicate is true.
+    // For constant operation, no predicate.
     auto const_op = builder.create<neura::ConstantOp>(
         arg.getLoc(), arg.getType(),
-        builder.getStringAttr("\%arg" + std::to_string(idx)),
-        builder.getBoolAttr(true));
+        builder.getStringAttr("\%arg" + std::to_string(idx)));
     arg.replaceAllUsesWith(const_op.getResult());
   }
 
diff --git a/test/affine2neura/bert/bert_node0/bert_node0.mlir b/test/affine2neura/bert/bert_node0/bert_node0.mlir
index 28d2221d..12f98cfd 100644
--- a/test/affine2neura/bert/bert_node0/bert_node0.mlir
+++ b/test/affine2neura/bert/bert_node0/bert_node0.mlir
@@ -15,10 +15,10 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10bert_node0PA128_KiPA128_b(%arg0: memref<?x128xi32>, %arg1: memref<?x128xi8>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %4 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64):  // 2 preds: ^bb0, ^bb2
diff --git a/test/affine2neura/bert/bert_node1/bert_node1.mlir b/test/affine2neura/bert/bert_node1/bert_node1.mlir
index 0f48d1fa..8e36c502 100644
--- a/test/affine2neura/bert/bert_node1/bert_node1.mlir
+++ b/test/affine2neura/bert/bert_node1/bert_node1.mlir
@@ -31,9 +31,9 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %3 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%4: i64):  // 2 preds: ^bb0, ^bb5
@@ -61,17 +61,16 @@ module attributes {} {
 // CHECK-NEXT: "neura.return"() : () -> ()
 // CHECK-NEXT: }
 
-
 // CTRL2DATA:        func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x1x1x1x1x128xi8>, i1>) -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?x1x128x1x1x128xi8>, i1>) -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %10 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.phi"(%10, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/affine2neura/bert/bert_node2/bert_node2.mlir b/test/affine2neura/bert/bert_node2/bert_node2.mlir
index 0c9e6831..0bc0a274 100644
--- a/test/affine2neura/bert/bert_node2/bert_node2.mlir
+++ b/test/affine2neura/bert/bert_node2/bert_node2.mlir
@@ -28,14 +28,14 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10bert_node2PA128_KiPA768_KfPA128_A768_f(%arg0: memref<?x128xi32>, %arg1: memref<?x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
-// CHECK-NEXT:  %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index
-// CHECK-NEXT:  %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:  %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:  %3 = "neura.constant"() <{predicate = true, value = false}> : () -> i1
-// CHECK-NEXT:  %4 = "neura.constant"() <{predicate = true, value = 30521 : i32}> : () -> i32
-// CHECK-NEXT:  %5 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:  %6 = "neura.constant"() <{predicate = true, value = 30522 : i32}> : () -> i32
-// CHECK-NEXT:  %7 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:  %0 = "neura.constant"() <{value = 768 : index}> : () -> index
+// CHECK-NEXT:  %1 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:  %2 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:  %3 = "neura.constant"() <{value = false}> : () -> i1
+// CHECK-NEXT:  %4 = "neura.constant"() <{value = 30521 : i32}> : () -> i32
+// CHECK-NEXT:  %5 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:  %6 = "neura.constant"() <{value = 30522 : i32}> : () -> i32
+// CHECK-NEXT:  %7 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:  %8 = "neura.cast"(%7) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:  neura.br %8 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%9: i64):  // 2 preds: ^bb0, ^bb9
diff --git a/test/affine2neura/bert/bert_node28/bert_node28.mlir b/test/affine2neura/bert/bert_node28/bert_node28.mlir
index 2d7616f9..a12273c8 100644
--- a/test/affine2neura/bert/bert_node28/bert_node28.mlir
+++ b/test/affine2neura/bert/bert_node28/bert_node28.mlir
@@ -36,10 +36,10 @@ module attributes {} {
   }
 }
 // CHECK: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %4 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64):  // 2 preds: ^bb0, ^bb8
@@ -82,19 +82,19 @@ module attributes {} {
 // CHECK-NEXT: "neura.return"() : () -> ()
 
 // CTRL2DATA:        func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x128x768xf32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x128x768xf32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x128x768xf32>, i1>) -> !neura.data<memref<?x128x768xf32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?x768x768xf32>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x768x768xf32>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?x768x768xf32>, i1>) -> !neura.data<memref<?x768x768xf32>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = "%arg2"}> : () -> !neura.data<memref<?x128x768xf32>, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = "%arg2"}> : () -> !neura.data<memref<?x128x768xf32>, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<memref<?x128x768xf32>, i1>) -> !neura.data<memref<?x128x768xf32>, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 768 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 768 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.grant_once"(%12) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %14 = neura.reserve : !neura.data<memref<?x128x768xf32>, i1>
 // CTRL2DATA-NEXT:     %15 = "neura.phi"(%14, %5) : (!neura.data<memref<?x128x768xf32>, i1>, !neura.data<memref<?x128x768xf32>, i1>) -> !neura.data<memref<?x128x768xf32>, i1>
diff --git a/test/affine2neura/bert/bert_node3/bert_node3.mlir b/test/affine2neura/bert/bert_node3/bert_node3.mlir
index 1988367f..19d121e4 100644
--- a/test/affine2neura/bert/bert_node3/bert_node3.mlir
+++ b/test/affine2neura/bert/bert_node3/bert_node3.mlir
@@ -15,10 +15,10 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10bert_node3PA128_A768_KfS2_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x128x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %4 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64):  // 2 preds: ^bb0, ^bb5
diff --git a/test/affine2neura/bert/bert_node8/bert_node8.mlir b/test/affine2neura/bert/bert_node8/bert_node8.mlir
index 38b8e0f3..b0cb6345 100644
--- a/test/affine2neura/bert/bert_node8/bert_node8.mlir
+++ b/test/affine2neura/bert/bert_node8/bert_node8.mlir
@@ -13,10 +13,10 @@ module attributes {} {
 }
 
 // CHECK:  func.func @_Z10bert_node8PA128_A1_KfPA128_A1_f(%arg0: memref<?x128x1xf32>, %arg1: memref<?x128x1xf32>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 7.680000e+02 : f32}> : () -> f32
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 7.680000e+02 : f32}> : () -> f32
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %4 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64):  // 2 preds: ^bb0, ^bb2
diff --git a/test/affine2neura/bert/bert_node9/bert_node9.mlir b/test/affine2neura/bert/bert_node9/bert_node9.mlir
index 90862cbc..333589ab 100644
--- a/test/affine2neura/bert/bert_node9/bert_node9.mlir
+++ b/test/affine2neura/bert/bert_node9/bert_node9.mlir
@@ -15,10 +15,10 @@ module attributes {} {
 
 
 // CHECK: func.func @_Z10bert_node9PA128_A768_KfPA128_A768_d(%arg0: memref<?x128x768xf32>, %arg1: memref<?x128x768xf64>) attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 768 : index}> : () -> index
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT: neura.br %4 : i64 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64):  // 2 preds: ^bb0, ^bb5
diff --git a/test/controflow_fuse/complex_nested/complex_nested.mlir b/test/controflow_fuse/complex_nested/complex_nested.mlir
index f08edae3..25fef2fc 100644
--- a/test/controflow_fuse/complex_nested/complex_nested.mlir
+++ b/test/controflow_fuse/complex_nested/complex_nested.mlir
@@ -66,13 +66,13 @@ module attributes {} {
 }
 
 // CHECK:   func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 32 : index}> : () -> index
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> i32
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = -128 : i32}> : () -> i32
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 32 : i32}> : () -> i32
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 32 : index}> : () -> index
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 128 : i32}> : () -> i32
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = -128 : i32}> : () -> i32
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 32 : i32}> : () -> i32
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:     %6 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %7 = "neura.cast"(%6) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %7 : i64 to ^bb1
 // CHECK-NEXT:   ^bb1(%8: i64):  // 2 preds: ^bb0, ^bb22
@@ -176,23 +176,23 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x32x32xi32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x32x32xi32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x32x32xi32>, i1>) -> !neura.data<memref<?x32x32xi32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?x32xi32>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x32xi32>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?x32xi32>, i1>) -> !neura.data<memref<?x32xi32>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 32 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 128 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = -128 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = -128 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 32 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{value = 32 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.grant_once"(%12) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %15 = "neura.grant_once"(%14) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %17 = "neura.grant_once"(%16) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %18 = neura.reserve : !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %19 = "neura.phi"(%18, %9) : (!neura.data<i32, i1>, !neura.data<i32, i1>) -> !neura.data<i32, i1>
@@ -542,7 +542,7 @@ module attributes {} {
 // CTRL2DATA-NEXT:     %312 = "neura.mul"(%311, %297) : (!neura.data<i32, i1>, !neura.data<i32, i1>) -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %313 = "neura.div"(%312, %298) : (!neura.data<i32, i1>, !neura.data<i32, i1>) -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     neura.store_indexed %313 to %294[%295, %296 : !neura.data<i64, i1>, !neura.data<i64, i1>] !neura.data<memref<?x32xi32>, i1> : !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %314 = "neura.add"(%296, %299) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>  
+// CTRL2DATA-NEXT:     %314 = "neura.add"(%296, %299) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     neura.ctrl_mov %314 -> %223 : !neura.data<i64, i1> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     neura.ctrl_mov %300 -> %221 : !neura.data<i64, i1> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     neura.ctrl_mov %301 -> %219 : !neura.data<i64, i1> !neura.data<i64, i1>
diff --git a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir
index 065fb6a4..435c9536 100644
--- a/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir
+++ b/test/controflow_fuse/non_perfect_nested/non_perfect_nested.mlir
@@ -66,19 +66,19 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref<?x128xi32>, %arg1: memref<?x128xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 4 : index}> : () -> index
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 3 : index}> : () -> index
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 2 : index}> : () -> index
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 100 : i32}> : () -> i32
-// CHECK-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3 : i32}> : () -> i32
-// CHECK-NEXT:     %7 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> i32
-// CHECK-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> i32
-// CHECK-NEXT:     %9 = "neura.constant"() <{predicate = true, value = -1000 : i32}> : () -> i32
-// CHECK-NEXT:     %10 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> i32
-// CHECK-NEXT:     %11 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 4 : index}> : () -> index
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 3 : index}> : () -> index
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 2 : index}> : () -> index
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 100 : i32}> : () -> i32
+// CHECK-NEXT:     %6 = "neura.constant"() <{value = 3 : i32}> : () -> i32
+// CHECK-NEXT:     %7 = "neura.constant"() <{value = 2 : i32}> : () -> i32
+// CHECK-NEXT:     %8 = "neura.constant"() <{value = 1000 : i32}> : () -> i32
+// CHECK-NEXT:     %9 = "neura.constant"() <{value = -1000 : i32}> : () -> i32
+// CHECK-NEXT:     %10 = "neura.constant"() <{value = 128 : i32}> : () -> i32
+// CHECK-NEXT:     %11 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:     %12 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %13 = "neura.cast"(%12) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %13 : i64 to ^bb1
 // CHECK-NEXT:   ^bb1(%14: i64):  // 2 preds: ^bb0, ^bb9
@@ -138,35 +138,35 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z29non_perfect_extra_computationPA128_iS0_(%arg0: memref<?x128xi32>, %arg1: memref<?x128xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x128xi32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x128xi32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x128xi32>, i1>) -> !neura.data<memref<?x128xi32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?x128xi32>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x128xi32>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?x128xi32>, i1>) -> !neura.data<memref<?x128xi32>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 4 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 4 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 3 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 2 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 2 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.grant_once"(%12) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{predicate = true, value = 100 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{value = 100 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %15 = "neura.grant_once"(%14) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{predicate = true, value = 3 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{value = 3 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %17 = "neura.grant_once"(%16) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %18 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %18 = "neura.constant"() <{value = 2 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %19 = "neura.grant_once"(%18) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %20 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %20 = "neura.constant"() <{value = 1000 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %21 = "neura.grant_once"(%20) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %22 = "neura.constant"() <{predicate = true, value = -1000 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %22 = "neura.constant"() <{value = -1000 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %23 = "neura.grant_once"(%22) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %24 = "neura.constant"() <{predicate = true, value = 128 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %24 = "neura.constant"() <{value = 128 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %25 = "neura.grant_once"(%24) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %26 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %26 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %27 = "neura.grant_once"(%26) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %28 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %28 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %29 = "neura.grant_once"(%28) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %30 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %31 = "neura.phi"(%30, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/controflow_fuse/perfect_nested/perfect_nested.mlir b/test/controflow_fuse/perfect_nested/perfect_nested.mlir
index 4f4447ab..66f71fe7 100644
--- a/test/controflow_fuse/perfect_nested/perfect_nested.mlir
+++ b/test/controflow_fuse/perfect_nested/perfect_nested.mlir
@@ -57,9 +57,9 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %3 : i64 to ^bb1
 // CHECK-NEXT:   ^bb1(%4: i64):  // 2 preds: ^bb0, ^bb5
@@ -88,9 +88,9 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CAST:     func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CAST-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CAST-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> i64
-// CAST-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
+// CAST-NEXT:     %0 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CAST-NEXT:     %1 = "neura.constant"() <{value = 128 : i64}> : () -> i64
+// CAST-NEXT:     %2 = "neura.constant"() <{value = 0 : i64}> : () -> i64
 // CAST-NEXT:     neura.br %2 : i64 to ^bb1
 // CAST-NEXT:   ^bb1(%3: i64):  // 2 preds: ^bb0, ^bb5
 // CAST-NEXT:     %4 = "neura.icmp"(%3, %1) <{cmpType = "slt"}> : (i64, i64) -> i1
@@ -113,15 +113,15 @@ module attributes {} {
 // CAST-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x1x1x1x1x128xi8>, i1>) -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?x1x128x1x1x128xi8>, i1>) -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %10 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.phi"(%10, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir
index 26810735..978a3f27 100644
--- a/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir
+++ b/test/controflow_fuse/perfect_reduction/perfect_reduction.mlir
@@ -46,10 +46,10 @@ module attributes {} {
 
 
 // CHECK: func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref<?x128xi32>) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:   %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:   neura.br %4, %2 : i64, i32 to ^bb1
 // CHECK-NEXT: ^bb1(%5: i64, %6: i32):  // 2 preds: ^bb0, ^bb5
@@ -78,10 +78,10 @@ module attributes {} {
 // CHECK-NEXT: }
 
 // CAST:     func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref<?x128xi32>) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CAST-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CAST-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> i64
-// CAST-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CAST-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
+// CAST-NEXT:     %0 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CAST-NEXT:     %1 = "neura.constant"() <{value = 128 : i64}> : () -> i64
+// CAST-NEXT:     %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CAST-NEXT:     %3 = "neura.constant"() <{value = 0 : i64}> : () -> i64
 // CAST-NEXT:     neura.br %3, %2 : i64, i32 to ^bb1
 // CAST-NEXT:   ^bb1(%4: i64, %5: i32):  // 2 preds: ^bb0, ^bb5
 // CAST-NEXT:     %6 = "neura.icmp"(%4, %1) <{cmpType = "slt"}> : (i64, i64) -> i1
@@ -104,15 +104,15 @@ module attributes {} {
 // CAST-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z27perfect_nested_reduction_2dPA128_i(%arg0: memref<?x128xi32>) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?x128xi32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x128xi32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x128xi32>, i1>) -> !neura.data<memref<?x128xi32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %10 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.phi"(%10, %3) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/controflow_fuse/simple_loop/simple_loop.mlir b/test/controflow_fuse/simple_loop/simple_loop.mlir
index 951b08ac..1bf2b0c0 100644
--- a/test/controflow_fuse/simple_loop/simple_loop.mlir
+++ b/test/controflow_fuse/simple_loop/simple_loop.mlir
@@ -32,7 +32,7 @@
 // RUN: --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA
 
 // RUN: mlir-neura-opt %t-llvm.mlir \
-// RUN: --assign-accelerator \ 
+// RUN: --assign-accelerator \
 // RUN: --lower-arith-to-neura \
 // RUN: --lower-memref-to-neura \
 // RUN: --lower-builtin-to-neura \
@@ -76,11 +76,11 @@ module attributes {} {
 
 
 // CHECK:      func.func @_Z11simple_loopPiS_(%arg0: memref<?xi32>, %arg1: memref<?xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1 : i32}> : () -> i32
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> i32
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 1 : i32}> : () -> i32
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 2 : i32}> : () -> i32
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %5 = "neura.cast"(%4) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %5 : i64 to ^bb1
 // CHECK-NEXT:   ^bb1(%6: i64):  // 2 preds: ^bb0, ^bb2
@@ -100,13 +100,13 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CANONICALIZE:       func.func @_Z11simple_loopPiS_(%arg0: memref<?xi32>, %arg1: memref<?xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> memref<?xi32>
-// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> memref<?xi32>
-// CANONICALIZE-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i32}> : () -> i32
-// CANONICALIZE-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> i32
-// CANONICALIZE-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> memref<?xi32>
+// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{value = "%arg1"}> : () -> memref<?xi32>
+// CANONICALIZE-NEXT:     %2 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %3 = "neura.constant"() <{value = 128 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %4 = "neura.constant"() <{value = 1 : i32}> : () -> i32
+// CANONICALIZE-NEXT:     %5 = "neura.constant"() <{value = 2 : i32}> : () -> i32
+// CANONICALIZE-NEXT:     %6 = "neura.constant"() <{value = 0 : i64}> : () -> i64
 // CANONICALIZE-NEXT:     neura.br %6, %3, %0, %5, %4, %1, %2 : i64, i64, memref<?xi32>, i32, i32, memref<?xi32>, i64 to ^bb1
 // CANONICALIZE-NEXT:   ^bb1(%7: i64, %8: i64, %9: memref<?xi32>, %10: i32, %11: i32, %12: memref<?xi32>, %13: i64):  // 2 preds: ^bb0, ^bb2
 // CANONICALIZE-NEXT:     %14 = "neura.icmp"(%7, %8) <{cmpType = "slt"}> : (i64, i64) -> i1
@@ -123,19 +123,19 @@ module attributes {} {
 // CANONICALIZE-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z11simple_loopPiS_(%arg0: memref<?xi32>, %arg1: memref<?xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?xi32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?xi32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?xi32>, i1>) -> !neura.data<memref<?xi32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<memref<?xi32>, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?xi32>, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<memref<?xi32>, i1>) -> !neura.data<memref<?xi32>, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 1 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 1 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = 2 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.grant_once"(%12) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %14 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %15 = "neura.phi"(%14, %5) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/controflow_fuse/simple_loop_reduction/simple_loop_reduction.mlir b/test/controflow_fuse/simple_loop_reduction/simple_loop_reduction.mlir
index a995893b..ba0f0d60 100644
--- a/test/controflow_fuse/simple_loop_reduction/simple_loop_reduction.mlir
+++ b/test/controflow_fuse/simple_loop_reduction/simple_loop_reduction.mlir
@@ -33,7 +33,7 @@
 // RUN: --transform-ctrl-to-data-flow | FileCheck %s -check-prefix=CTRL2DATA
 
 // RUN: mlir-neura-opt %t-llvm.mlir \
-// RUN: --assign-accelerator \ 
+// RUN: --assign-accelerator \
 // RUN: --lower-arith-to-neura \
 // RUN: --lower-memref-to-neura \
 // RUN: --lower-builtin-to-neura \
@@ -74,10 +74,10 @@ module attributes {} {
 }
 
 // CHECK: func.func @_Z10simpleloopv() -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %4, %2 : i64, i32 to ^bb1
 // CHECK-NEXT:   ^bb1(%5: i64, %6: i32):  // 2 preds: ^bb0, ^bb2
@@ -95,10 +95,10 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CANONICALIZE:        func.func @_Z10simpleloopv() -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CANONICALIZE-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{value = 128 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %2 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CANONICALIZE-NEXT:     %3 = "neura.constant"() <{value = 0 : i64}> : () -> i64
 // CANONICALIZE-NEXT:     neura.br %3, %2, %1, %0 : i64, i32, i64, i64 to ^bb1
 // CANONICALIZE-NEXT:   ^bb1(%4: i64, %5: i32, %6: i64, %7: i64):  // 2 preds: ^bb0, ^bb2
 // CANONICALIZE-NEXT:     %8 = "neura.icmp"(%4, %6) <{cmpType = "slt"}> : (i64, i64) -> i1
@@ -113,13 +113,13 @@ module attributes {} {
 // CANONICALIZE-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z10simpleloopv() -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %8 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.phi"(%8, %1) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/mapping_quality/branch_for.mlir b/test/mapping_quality/branch_for.mlir
index 5b438daa..f0c89cb3 100644
--- a/test/mapping_quality/branch_for.mlir
+++ b/test/mapping_quality/branch_for.mlir
@@ -63,7 +63,7 @@
 // RUN:   --fold-constant \
 // RUN:   --insert-data-mov \
 // RUN:   --map-to-accelerator="mapping-strategy=heuristic backtrack-config=customized" \
-// RUN:   --generate-code 
+// RUN:   --generate-code
 // RUN: FileCheck %s --input-file=tmp-generated-instructions.yaml -check-prefix=YAML
 // RUN: FileCheck %s --input-file=tmp-generated-instructions.asm --check-prefix=ASM
 
@@ -87,11 +87,11 @@ func.func @loop_test() -> f32 {
 }
 
 // CHECK:      func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %4 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = 10 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %4 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:   neura.br %1, %4 : !neura.data<i64, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT: ^bb1(%5: !neura.data<i64, i1>, %6: !neura.data<f32, i1>):  // 2 preds: ^bb0, ^bb1
 // CHECK-NEXT:   %7 = "neura.fadd"(%6, %3) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
@@ -103,8 +103,8 @@ func.func @loop_test() -> f32 {
 // CHECK-NEXT: }
 
 // CANONICALIZE:       func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> f32
+// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{value = 0 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> f32
 // CANONICALIZE-NEXT:     neura.br %0, %1 : i64, f32 to ^bb1
 // CANONICALIZE-NEXT:   ^bb1(%2: i64, %3: f32):  // 2 preds: ^bb0, ^bb1
 // CANONICALIZE-NEXT:     %4 = "neura.fadd"(%3) {rhs_const_value = 3.000000e+00 : f32} : (f32) -> f32
@@ -116,9 +116,9 @@ func.func @loop_test() -> f32 {
 // CANONICALIZE-NEXT:   }
 
 // CTRL2DATA:        func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %4 = neura.reserve : !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.phi"(%4, %3) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
@@ -186,7 +186,7 @@ func.func @loop_test() -> f32 {
 // MOV-NEXT:     %25 = "neura.data_mov"(%24) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // MOV-NEXT:     "neura.return"(%25) : (!neura.data<f32, i1>) -> ()
 // MOV-NEXT:   }
- 
+
 // MAPPING:      module {
 // MAPPING-NEXT:   func.func @loop_test() -> f32 attributes {accelerator = "neura", mapping_info = {compiled_ii = 4 : i32, mapping_mode = "spatial-temporal", mapping_strategy = "heuristic", rec_mii = 4 : i32, res_mii = 1 : i32, x_tiles = 4 : i32, y_tiles = 4 : i32}} {
 
diff --git a/test/mapping_quality/tiny_loop.mlir b/test/mapping_quality/tiny_loop.mlir
index dd7f13e9..66f6f70a 100644
--- a/test/mapping_quality/tiny_loop.mlir
+++ b/test/mapping_quality/tiny_loop.mlir
@@ -57,10 +57,10 @@ module {
 }
 
 // CHECK:     func.func @simple_add_loop() -> i64 attributes {accelerator = "neura"} {
-// CHECK-NEXT: %0 = "neura.constant"() <{predicate = true, value = 16 : i64}> : () -> i64
-// CHECK-NEXT: %1 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CHECK-NEXT: %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CHECK-NEXT: %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
+// CHECK-NEXT: %0 = "neura.constant"() <{value = 16 : i64}> : () -> i64
+// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CHECK-NEXT: %2 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : i64}> : () -> i64
 // CHECK-NEXT: neura.br %3, %2, %0, %1 : i64, i64, i64, i64 to ^bb1
 // CHECK-NEXT: ^bb1(%4: i64, %5: i64, %6: i64, %7: i64):  // 2 preds: ^bb0, ^bb2
 // CHECK-NEXT: %8 = "neura.icmp"(%4, %6) <{cmpType = "slt"}> : (i64, i64) -> i1
diff --git a/test/neura/ctrl/branch.mlir b/test/neura/ctrl/branch.mlir
index 60aae1ef..696991f8 100644
--- a/test/neura/ctrl/branch.mlir
+++ b/test/neura/ctrl/branch.mlir
@@ -36,12 +36,12 @@ func.func @test(%in: i64) -> f32 {
 
 
 // CHECK:   func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:     %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CHECK-NEXT:     neura.cond_br %6 : !neura.data<i1, i1> then %4, %5 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb2 else %2, %3 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT:   ^bb1(%7: !neura.data<f32, i1>, %8: !neura.data<f32, i1>):  // pred: ^bb0
@@ -55,15 +55,15 @@ func.func @test(%in: i64) -> f32 {
 // CHECK-NEXT:   }
 
 // CTRL2DATA:   func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %10 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
diff --git a/test/neura/ctrl/branch_for.mlir b/test/neura/ctrl/branch_for.mlir
index 7b51971c..200aaa1f 100644
--- a/test/neura/ctrl/branch_for.mlir
+++ b/test/neura/ctrl/branch_for.mlir
@@ -87,11 +87,11 @@ func.func @loop_test() -> f32 {
 }
 
 // CHECK:      func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = 10 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %4 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = 10 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %4 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:   neura.br %1, %4 : !neura.data<i64, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT: ^bb1(%5: !neura.data<i64, i1>, %6: !neura.data<f32, i1>):  // 2 preds: ^bb0, ^bb1
 // CHECK-NEXT:   %7 = "neura.fadd"(%6, %3) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
@@ -103,8 +103,8 @@ func.func @loop_test() -> f32 {
 // CHECK-NEXT: }
 
 // CANONICALIZE:       func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
-// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> f32
+// CANONICALIZE-NEXT:     %0 = "neura.constant"() <{value = 0 : i64}> : () -> i64
+// CANONICALIZE-NEXT:     %1 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> f32
 // CANONICALIZE-NEXT:     neura.br %0, %1 : i64, f32 to ^bb1
 // CANONICALIZE-NEXT:   ^bb1(%2: i64, %3: f32):  // 2 preds: ^bb0, ^bb1
 // CANONICALIZE-NEXT:     %4 = "neura.fadd"(%3) {rhs_const_value = 3.000000e+00 : f32} : (f32) -> f32
@@ -116,9 +116,9 @@ func.func @loop_test() -> f32 {
 // CANONICALIZE-NEXT:   }
 
 // CTRL2DATA:        func.func @loop_test() -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 0.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %4 = neura.reserve : !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.phi"(%4, %3) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
@@ -263,4 +263,4 @@ func.func @loop_test() -> f32 {
 // ASM-NEXT: } (t=4)
 // ASM-NEXT: {
 // ASM-NEXT:   DATA_MOV, [EAST, RED] -> [NORTH, RED]
-// ASM-NEXT: } (t=5)
+// ASM-NEXT: } (t=5)
\ No newline at end of file
diff --git a/test/neura/ctrl/branch_with_and_without_arg.mlir b/test/neura/ctrl/branch_with_and_without_arg.mlir
index 88439f1a..76b67e00 100644
--- a/test/neura/ctrl/branch_with_and_without_arg.mlir
+++ b/test/neura/ctrl/branch_with_and_without_arg.mlir
@@ -34,11 +34,11 @@ func.func @test(%in: i64) -> f32 {
 }
 
 // CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %4 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:   %5 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CHECK-NEXT:   neura.cond_br %5 : !neura.data<i1, i1> then %4, %3 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb2 else %2, %3 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT: ^bb1(%6: !neura.data<f32, i1>, %7: !neura.data<f32, i1>):  // pred: ^bb0
@@ -52,13 +52,13 @@ func.func @test(%in: i64) -> f32 {
 // CHECK-NEXT: }
 
 // CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %8 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
diff --git a/test/neura/ctrl/branch_without_arg.mlir b/test/neura/ctrl/branch_without_arg.mlir
index 7cec73c1..64478ab2 100644
--- a/test/neura/ctrl/branch_without_arg.mlir
+++ b/test/neura/ctrl/branch_without_arg.mlir
@@ -35,12 +35,12 @@ func.func @test(%in: i64) -> f32 {
 }
 
 // CHECK: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:   %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %4 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:   %5 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:   %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CHECK-NEXT:   neura.cond_br %6 : !neura.data<i1, i1> then %4, %5 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb2 else %2, %3 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT: ^bb1(%7: !neura.data<f32, i1>, %8: !neura.data<f32, i1>):
@@ -54,15 +54,15 @@ func.func @test(%in: i64) -> f32 {
 // CHECK-NEXT: }
 
 // CTRL2DATA: func.func @test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %10 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
diff --git a/test/neura/ctrl/for_with_if.mlir b/test/neura/ctrl/for_with_if.mlir
index 53e40bbf..99e0ed22 100644
--- a/test/neura/ctrl/for_with_if.mlir
+++ b/test/neura/ctrl/for_with_if.mlir
@@ -51,14 +51,14 @@ module attributes {} {
 }
 
 // CHECK:        func.func @_Z11for_with_ifPi(%arg0: memref<?xi32>) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> i32
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> i32
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 1 : i32}> : () -> i32
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = -5 : i32}> : () -> i32
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 1 : index}> : () -> index
-// CHECK-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 128 : index}> : () -> index
-// CHECK-NEXT:     %7 = "neura.constant"() <{predicate = true, value = 0 : index}> : () -> index
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 1000 : i32}> : () -> i32
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 2 : i32}> : () -> i32
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 1 : i32}> : () -> i32
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = -5 : i32}> : () -> i32
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 1 : index}> : () -> index
+// CHECK-NEXT:     %6 = "neura.constant"() <{value = 128 : index}> : () -> index
+// CHECK-NEXT:     %7 = "neura.constant"() <{value = 0 : index}> : () -> index
 // CHECK-NEXT:     %8 = "neura.cast"(%7) <{cast_type = "index_to_int"}> : (index) -> i64
 // CHECK-NEXT:     neura.br %8, %0 : i64, i32 to ^bb1
 // CHECK-NEXT:   ^bb1(%9: i64, %10: i32):  // 2 preds: ^bb0, ^bb6
@@ -88,23 +88,23 @@ module attributes {} {
 // CHECK-NEXT:   }
 
 // CTRL2DATA:        func.func @_Z11for_with_ifPi(%arg0: memref<?xi32>) -> i32 attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<memref<?xi32>, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?xi32>, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<memref<?xi32>, i1>) -> !neura.data<memref<?xi32>, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1000 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 1000 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 2 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 2 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 1 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 1 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = -5 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = -5 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %12 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.grant_once"(%12) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{predicate = true, value = 128 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %14 = "neura.constant"() <{value = 128 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %15 = "neura.grant_once"(%14) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %16 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %17 = "neura.grant_once"(%16) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %18 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %19 = "neura.phi"(%18, %13) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/neura/ctrl/nested_branch.mlir b/test/neura/ctrl/nested_branch.mlir
index c4008240..5a145a99 100644
--- a/test/neura/ctrl/nested_branch.mlir
+++ b/test/neura/ctrl/nested_branch.mlir
@@ -39,12 +39,12 @@ func.func @complex_test(%in: i64) -> f32 {
 }
 
 // CHECK:       func.func @complex_test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CHECK-NEXT:     %6 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CHECK-NEXT:     neura.cond_br %6 : !neura.data<i1, i1> then %4, %5 : !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb3 else %2, %3, %2 : !neura.data<f32, i1>, !neura.data<f32, i1>, !neura.data<f32, i1> to ^bb1
 // CHECK-NEXT:   ^bb1(%7: !neura.data<f32, i1>, %8: !neura.data<f32, i1>, %9: !neura.data<f32, i1>):  // 2 preds: ^bb0, ^bb2
@@ -61,15 +61,15 @@ func.func @complex_test(%in: i64) -> f32 {
 // CHECK-NEXT:   }
 
 // CTRL2DATA:        func.func @complex_test(%arg0: i64) -> f32 attributes {accelerator = "neura"} {
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %1 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = 1.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 2.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 3.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 4.000000e+00 : f32}> : () -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<f32, i1>) -> !neura.data<f32, i1>
 // CTRL2DATA-NEXT:     %10 = "neura.icmp"(%0, %1) <{cmpType = "eq"}> : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i1, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
diff --git a/test/neura/for_loop/kernel_test.mlir b/test/neura/for_loop/kernel_test.mlir
index e1271f9a..75567013 100644
--- a/test/neura/for_loop/kernel_test.mlir
+++ b/test/neura/for_loop/kernel_test.mlir
@@ -32,14 +32,14 @@
 // RUN:   --insert-data-mov \
 // RUN:  | FileCheck %s --check-prefix=CHECK-MOV
 
-// CHECK:       func.func 
+// CHECK:       func.func
 // CHECK:       accelerator = "neura"
-// CHECK-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
-// CHECK-NEXT:     %1 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
-// CHECK-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg2"}> : () -> !neura.data<!llvm.ptr, i1>
-// CHECK-NEXT:     %3 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
-// CHECK-NEXT:     %5 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
+// CHECK-NEXT:     %1 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
+// CHECK-NEXT:     %2 = "neura.constant"() <{value = "%arg2"}> : () -> !neura.data<!llvm.ptr, i1>
+// CHECK-NEXT:     %3 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %4 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CHECK-NEXT:     %5 = "neura.constant"() <{value = 32 : i64}> : () -> !neura.data<i64, i1>
 // CHECK-NEXT:     %6 = "neura.load"(%1) : (!neura.data<!llvm.ptr, i1>) -> !neura.data<f32, i1>
 // CHECK-NEXT:     neura.br %3, %6, %0, %2, %1, %4, %5 : !neura.data<i64, i1>, !neura.data<f32, i1>, !neura.data<!llvm.ptr, i1>, !neura.data<!llvm.ptr, i1>, !neura.data<!llvm.ptr, i1>, !neura.data<i64, i1>, !neura.data<i64, i1> to ^bb1
 // CHECK-NEXT:   ^bb1(%7: !neura.data<i64, i1>, %8: !neura.data<f32, i1>, %9: !neura.data<!llvm.ptr, i1>, %10: !neura.data<!llvm.ptr, i1>, %11: !neura.data<!llvm.ptr, i1>, %12: !neura.data<i64, i1>, %13: !neura.data<i64, i1>):  // 2 preds: ^bb0, ^bb1
@@ -58,11 +58,11 @@
 // CHECK-NEXT:   }
 
 // Verifies the neura ops are generated. And fusion happens.
-// CHECK-FUSED:       func.func 
+// CHECK-FUSED:       func.func
 // CHECK-FUSED:       accelerator = "neura"
 // CHECK-FUSED-NEXT:     %0 = "neura.grant_once"() <{constant_value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-FUSED-NEXT:     %1 = "neura.grant_once"() <{constant_value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
-// CHECK-FUSED-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
+// CHECK-FUSED-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-FUSED-NEXT:     %3 = "neura.grant_once"() <{constant_value = "%arg2"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-FUSED-NEXT:     %4 = "neura.grant_once"() <{constant_value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CHECK-FUSED-NEXT:     %5 = "neura.grant_once"() <{constant_value = 1 : i64}> : () -> !neura.data<i64, i1>
@@ -109,11 +109,11 @@
 // CHECK-FUSED-NEXT:     "neura.return"() : () -> ()
 // CHECK-FUSED-NEXT:   }
 
-// CHECK-MOV:        func.func 
+// CHECK-MOV:        func.func
 // CHECK-MOV:        accelerator = "neura"
 // CHECK-MOV-NEXT:     %0 = "neura.grant_once"() <{constant_value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-MOV-NEXT:     %1 = "neura.grant_once"() <{constant_value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
-// CHECK-MOV-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
+// CHECK-MOV-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-MOV-NEXT:     %3 = "neura.grant_once"() <{constant_value = "%arg2"}> : () -> !neura.data<!llvm.ptr, i1>
 // CHECK-MOV-NEXT:     %4 = "neura.grant_once"() <{constant_value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CHECK-MOV-NEXT:     %5 = "neura.grant_once"() <{constant_value = 1 : i64}> : () -> !neura.data<i64, i1>
diff --git a/test/neura/for_loop/relu_test.mlir b/test/neura/for_loop/relu_test.mlir
index 74bd2c5c..2331ab45 100644
--- a/test/neura/for_loop/relu_test.mlir
+++ b/test/neura/for_loop/relu_test.mlir
@@ -18,12 +18,12 @@
 
 // CHECK:      func.func
 // CHECK:      accelerator = "neura"
-// CHECK-NEXT:   %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !llvm.ptr
-// CHECK-NEXT:   %1 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !llvm.ptr
-// CHECK-NEXT:   %2 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> i64
-// CHECK-NEXT:   %3 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> i32
-// CHECK-NEXT:   %4 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> i64
-// CHECK-NEXT:   %5 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> i64
+// CHECK-NEXT:   %0 = "neura.constant"() <{value = "%arg0"}> : () -> !llvm.ptr
+// CHECK-NEXT:   %1 = "neura.constant"() <{value = "%arg1"}> : () -> !llvm.ptr
+// CHECK-NEXT:   %2 = "neura.constant"() <{value = 0 : i64}> : () -> i64
+// CHECK-NEXT:   %3 = "neura.constant"() <{value = 0 : i32}> : () -> i32
+// CHECK-NEXT:   %4 = "neura.constant"() <{value = 1 : i64}> : () -> i64
+// CHECK-NEXT:   %5 = "neura.constant"() <{value = 32 : i64}> : () -> i64
 // CHECK-NEXT:   neura.br %2, %0, %3, %1, %4, %5 : i64, !llvm.ptr, i32, !llvm.ptr, i64, i64 to ^bb2
 // CHECK-NEXT: ^bb1:  // pred: ^bb4
 // CHECK-NEXT:   "neura.return"() : () -> ()
@@ -47,17 +47,17 @@
 
 // CTRL2DATA:       func.func
 // CTRL2DATA:       accelerator = "neura"
-// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{predicate = true, value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
+// CTRL2DATA-NEXT:     %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<!llvm.ptr, i1>
 // CTRL2DATA-NEXT:     %1 = "neura.grant_once"(%0) : (!neura.data<!llvm.ptr, i1>) -> !neura.data<!llvm.ptr, i1>
-// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{predicate = true, value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
+// CTRL2DATA-NEXT:     %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<!llvm.ptr, i1>
 // CTRL2DATA-NEXT:     %3 = "neura.grant_once"(%2) : (!neura.data<!llvm.ptr, i1>) -> !neura.data<!llvm.ptr, i1>
-// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{predicate = true, value = 0 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %4 = "neura.constant"() <{value = 0 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %5 = "neura.grant_once"(%4) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{predicate = true, value = 0 : i32}> : () -> !neura.data<i32, i1>
+// CTRL2DATA-NEXT:     %6 = "neura.constant"() <{value = 0 : i32}> : () -> !neura.data<i32, i1>
 // CTRL2DATA-NEXT:     %7 = "neura.grant_once"(%6) : (!neura.data<i32, i1>) -> !neura.data<i32, i1>
-// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{predicate = true, value = 1 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %8 = "neura.constant"() <{value = 1 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %9 = "neura.grant_once"(%8) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
-// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{predicate = true, value = 32 : i64}> : () -> !neura.data<i64, i1>
+// CTRL2DATA-NEXT:     %10 = "neura.constant"() <{value = 32 : i64}> : () -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %11 = "neura.grant_once"(%10) : (!neura.data<i64, i1>) -> !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %12 = neura.reserve : !neura.data<i64, i1>
 // CTRL2DATA-NEXT:     %13 = "neura.phi"(%12, %11) : (!neura.data<i64, i1>, !neura.data<i64, i1>) -> !neura.data<i64, i1>
diff --git a/test/neura/interpreter/basic_operation/add.mlir b/test/neura/interpreter/basic_operation/add.mlir
index 9ecdc8b3..b42009d8 100644
--- a/test/neura/interpreter/basic_operation/add.mlir
+++ b/test/neura/interpreter/basic_operation/add.mlir
@@ -50,13 +50,12 @@ func.func @test_add_zero() -> f32 {
 // https://github.com/coredac/dataflow/issues/116
 
 // ===----------------------------------------------------------------------===//
-// Test 5: Add with operation predicate 0
-// ===----------------------------------------------------------------------===//
-// func.func @test_add_predicate_zero() -> f32 {
-//   %a = arith.constant 10.0 : f32
-//   %b = arith.constant 32.0 : f32
-//   %pred = arith.constant 0 : i1
-//   %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-//   %res = "neura.add"(%a, %b, %pred_f32) : (f32, f32, f32) -> f32
+// Test 5: Add with operation embed predicate 0
+// ===----------------------------------------------------------------------===//
+// func.func @test_add__embed_predicate_zero() -> f32 {
+//   %a = "neura.constant"() {value = 10.0 : f32, predicate = false} : () -> f32
+//   %b = "neura.constant"() {value = 32.0 : f32, predicate = false} : () -> f32
+//   %res = "neura.add"(%a, %b) : (f32, f32) -> f32
+//   // [neura-interpreter]  → Output: 0.000000
 //   return %res : f32
 // }
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/cast.mlir b/test/neura/interpreter/basic_operation/cast.mlir
index dbb6b381..e163fecb 100644
--- a/test/neura/interpreter/basic_operation/cast.mlir
+++ b/test/neura/interpreter/basic_operation/cast.mlir
@@ -41,19 +41,9 @@ func.func @test_cast_i2bool() -> i1 {
 }
 
 // f2i with true predicate
-func.func @test_cast_predicated() -> i32 {
-  %val = arith.constant 5.5 : f32
-  %pred = arith.constant 1 : i1
-  %res = "neura.cast"(%val, %pred) { cast_type = "f2i" } : (f32, i1) -> i32
+func.func @test_cast_embed_predicated() -> i32 {
+  %val = "neura.constant"() {value = 5.5 : f32} : () -> f32
+  %res = "neura.cast"(%val) { cast_type = "f2i" } : (f32) -> i32
   // CHECK: [neura-interpreter]  → Output: 6.000000
   return %res : i32
-}
-
-// f2i with false predicate
-func.func @test_cast_predicate_false() -> i32 {
-  %val = arith.constant 5.5 : f32
-  %pred = arith.constant 0 : i1
-  %res = "neura.cast"(%val, %pred) { cast_type = "f2i" } : (f32, i1) -> i32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : i32
 }
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/cond_br.mlir b/test/neura/interpreter/basic_operation/cond_br.mlir
index c0d73fb3..c5f21a08 100644
--- a/test/neura/interpreter/basic_operation/cond_br.mlir
+++ b/test/neura/interpreter/basic_operation/cond_br.mlir
@@ -1,8 +1,8 @@
 // RUN: neura-interpreter %s --verbose | FileCheck %s
 
 func.func @test_cond_br_true() {
-  %cond = arith.constant 1 : i1 
-  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  %cond = arith.constant 1 : i1
+  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
   // CHECK:  [neura-interpreter]  → Output: (void)
 ^bb1:
   return
@@ -11,8 +11,8 @@ func.func @test_cond_br_true() {
 }
 
 func.func @test_cond_br_false() {
-  %cond = arith.constant 0 : i1  
-  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  %cond = arith.constant 0 : i1
+  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
   // CHECK:  [neura-interpreter]  → Output: (void)
 ^bb1:
   return
@@ -20,24 +20,23 @@ func.func @test_cond_br_false() {
   return
 }
 
-func.func @test_cond_br_with_valid_predicate() {
-  %cond = arith.constant 1 : i1
-  %pred = arith.constant 1 : i32  
-  "neura.cond_br"(%cond, %pred) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 1, 0, 0>} : (i1, i32) -> ()
-  // CHECK:  [neura-interpreter]  → Output: (void)
-^bb1:
-  return
-^bb2:
-  return
-}
+// func.func @test_cond_br_with_valid_predicate() {
+//   %cond = arith.constant 1 : i1
+//   %pred = arith.constant 1 : i32
+//   "neura.cond_br"(%cond, %pred) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 1, 0, 0>} : (i1, i32) -> ()
+// ^bb1:
+//   return
+// ^bb2:
+//   return
+// }
 
 func.func @test_nested_cond_br() {
-  %cond1 = arith.constant 1 : i1  
-  "neura.cond_br"(%cond1) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  %cond1 = arith.constant 1 : i1
+  "neura.cond_br"(%cond1) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^bb1:
-  %cond2 = arith.constant 0 : i1 
-  "neura.cond_br"(%cond2) [^bb3, ^bb4] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  %cond2 = arith.constant 0 : i1
+  "neura.cond_br"(%cond2) [^bb3, ^bb4] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
   // CHECK:  [neura-interpreter]  → Output: (void)
 
 ^bb2:
diff --git a/test/neura/interpreter/basic_operation/fadd.mlir b/test/neura/interpreter/basic_operation/fadd.mlir
index 9c9631ca..98834622 100644
--- a/test/neura/interpreter/basic_operation/fadd.mlir
+++ b/test/neura/interpreter/basic_operation/fadd.mlir
@@ -42,32 +42,4 @@ func.func @test_fadd_zero() -> f32 {
   %res = "neura.fadd"(%a, %b) : (f32, f32) -> f32
   // CHECK: [neura-interpreter]  → Output: 25.500000
   return %res : f32
-}
-
-// TODO: Remove tests with predicate handling because we plan to remove the predicate attribute in
-// https://github.com/coredac/dataflow/issues/116
-
-// ===----------------------------------------------------------------------===//
-// Test 4: Predicate handling in neura.fadd
-// ===----------------------------------------------------------------------===//
-// func.func @test_fadd_invalid_predicate() -> f32 {
-//   %a = arith.constant 0.0 : f32
-//   %b = arith.constant 25.5 : f32
-//   %pred = arith.constant 0 : i1
-//   %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-//   %res = "neura.fadd"(%a, %b, %pred_f32) : (f32, f32, f32) -> f32
-//   return %res : f32
-// }
-
-// ===----------------------------------------------------------------------===//
-// Test 5: Nested predicate handling in neura.fadd
-// ===----------------------------------------------------------------------===//
-// func.func @test_nested_fadd_invalid_predicate() -> f32 {
-//   %a = arith.constant 0.0 : f32
-//   %b = arith.constant 25.5 : f32
-//   %pred = arith.constant 0 : i1
-//   %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-//   %tmp = "neura.fadd"(%a, %b, %pred_f32) : (f32, f32, f32) -> f32
-//   %res = "neura.fadd"(%tmp, %b, %pred_f32) : (f32, f32, f32) -> f32
-//   return %res : f32
-// }
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/fadd_fadd.mlir b/test/neura/interpreter/basic_operation/fadd_fadd.mlir
index 204ee439..1607be07 100644
--- a/test/neura/interpreter/basic_operation/fadd_fadd.mlir
+++ b/test/neura/interpreter/basic_operation/fadd_fadd.mlir
@@ -28,38 +28,4 @@ func.func @test_fadd_fadd_zero() -> f32 {
   %res = "neura.fadd_fadd"(%a, %b, %c) : (f32, f32, f32) -> f32
   // CHECK: [neura-interpreter]  → Output: 10.000000
   return %res : f32
-}
-
-// Test with valid predicate: (3.0 + 1.0) + 2.0 = 6.0
-func.func @test_fadd_fadd_with_valid_predicate() -> f32 {
-  %a = arith.constant 3.0 : f32
-  %b = arith.constant 1.0 : f32
-  %c = arith.constant 2.0 : f32
-  %pred = arith.constant 1 : i1 
-  %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-  %res = "neura.fadd_fadd"(%a, %b, %c, %pred_f32) : (f32, f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 6.000000
-  return %res : f32
-}
-
-// Test with false predicate (should return 0)
-func.func @test_fadd_fadd_with_invalid_predicate() -> f32 {
-  %a = arith.constant 10.0 : f32
-  %b = arith.constant 20.0 : f32
-  %c = arith.constant 30.0 : f32
-  %pred = arith.constant 0 : i1  
-  %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-  %res = "neura.fadd_fadd"(%a, %b, %c, %pred_f32) : (f32, f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : f32
-}
-
-// Test with invalid input predicate
-func.func @test_fadd_fadd_with_invalid_input_predicate() -> f32 {
-  %a = "neura.constant"() {value = 5.0 : f32, predicate = false} : () -> f32
-  %b = arith.constant 3.0 : f32 
-  %c = arith.constant 2.0 : f32
-  %res = "neura.fadd_fadd"(%a, %b, %c) : (f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : f32
 }
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/fdiv.mlir b/test/neura/interpreter/basic_operation/fdiv.mlir
index af160c1b..2126c048 100644
--- a/test/neura/interpreter/basic_operation/fdiv.mlir
+++ b/test/neura/interpreter/basic_operation/fdiv.mlir
@@ -48,24 +48,13 @@ func.func @test_fdiv_zero_dividend() -> f32 {
   return %res : f32
 }
 
-// TODO: Remove Test with predicate because we plan to remove the predicate attribute in
-// https://github.com/coredac/dataflow/issues/116
-
-// func.func @test_fdiv_with_predicate_true() -> f32 {
-//   %a = arith.constant 15.0 : f32
-//   %b = arith.constant 3.0 : f32
-//   %pred = arith.constant 1 : i32
-//   %res = "neura.fdiv"(%a, %b, %pred) : (f32, f32, i32) -> f32
-//   return %res : f32
-// }
-
-// func.func @test_fdiv_with_predicate_false() -> f32 {
-//   %a = arith.constant 20.0 : f32
-//   %b = arith.constant 4.0 : f32
-//   %pred = arith.constant 0 : i32
-//   %res = "neura.fdiv"(%a, %b, %pred) : (f32, f32, i32) -> f32
-//   return %res : f32
-// }
+func.func @test_fdiv_with_embed_predicate_true() -> f32 {
+  %a = "neura.constant"() {value = 15.0 : f32} : () -> f32
+  %b = "neura.constant"() {value = 3.0 : f32} : () -> f32
+  %res = "neura.fdiv"(%a, %b) : (f32, f32) -> f32
+  // CHECK: [neura-interpreter]  → Output: 5.000000
+  return %res : f32
+}
 
 func.func @test_fdiv_f64() -> f64 {
   %a = arith.constant 10.5 : f64
diff --git a/test/neura/interpreter/basic_operation/fmul.mlir b/test/neura/interpreter/basic_operation/fmul.mlir
index 40ba2daa..4db9fa84 100644
--- a/test/neura/interpreter/basic_operation/fmul.mlir
+++ b/test/neura/interpreter/basic_operation/fmul.mlir
@@ -36,23 +36,10 @@ func.func @test_fmul_zero() -> f32 {
 // ===----------------------------------------------------------------------===//
 // Test 4: Valid neura.fmul with three operands (including predicate)
 // ===----------------------------------------------------------------------===//
-func.func @test_fmul_with_predicate() -> f32 {
-  %a = arith.constant 2.0 : f32
-  %b = arith.constant 5.0 : f32
-  %p = arith.constant 1.0 : f32  // Non-zero predicate
-  %res = "neura.fmul"(%a, %b, %p) : (f32, f32, f32) -> f32
+func.func @test_fmul_with_embed_predicate() -> f32 {
+  %a = "neura.constant"() {value = 2.0 : f32} : () -> f32
+  %b = "neura.constant"() {value = 5.0 : f32} : () -> f32
+  %res = "neura.fmul"(%a, %b) : (f32, f32) -> f32
   // CHECK: [neura-interpreter]  → Output: 10.000000
   return %res : f32
-}
-
-// ===----------------------------------------------------------------------===//
-// Test 5: Neura.fmul with zero predicate (Negative case)
-// ===----------------------------------------------------------------------===//
-func.func @test_fmul_zero_predicate() -> f32 {
-  %a = arith.constant 2.0 : f32
-  %b = arith.constant 5.0 : f32
-  %p = arith.constant 0.0 : f32  // Zero predicate
-  %res = "neura.fmul"(%a, %b, %p) : (f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : f32
 }
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/fmul_add.mlir b/test/neura/interpreter/basic_operation/fmul_add.mlir
index 402c5f9a..4f747c75 100644
--- a/test/neura/interpreter/basic_operation/fmul_add.mlir
+++ b/test/neura/interpreter/basic_operation/fmul_add.mlir
@@ -38,36 +38,4 @@ func.func @test_fmul_fadd_decimal() -> f32 {
   %res = "neura.fmul_fadd"(%a, %b, %c) : (f32, f32, f32) -> f32
   // CHECK: [neura-interpreter]  → Output: 6.500000
   return %res : f32
-}
-
-// (4.0 * 2.0) + 1.0 = 9.0
-func.func @test_fmul_fadd_with_valid_predicate() -> f32 {
-  %a = arith.constant 4.0 : f32
-  %b = arith.constant 2.0 : f32
-  %c = arith.constant 1.0 : f32
-  %pred = arith.constant 1 : i1  // predicate 为 true
-  %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-  %res = "neura.fmul_fadd"(%a, %b, %c, %pred_f32) : (f32, f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 9.000000
-  return %res : f32
-}
-
-func.func @test_fmul_fadd_with_invalid_predicate() -> f32 {
-  %a = arith.constant 3.0 : f32
-  %b = arith.constant 3.0 : f32
-  %c = arith.constant 3.0 : f32
-  %pred = arith.constant 0 : i1
-  %pred_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-  %res = "neura.fmul_fadd"(%a, %b, %c, %pred_f32) : (f32, f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : f32
-}
-
-func.func @test_fmul_fadd_with_invalid_input_predicate() -> f32 {
-  %a = arith.constant 2.0 : f32
-  %b = "neura.constant"() {value = 5.0 : f32, predicate = false} : () -> f32
-  %c = arith.constant 3.0 : f32
-  %res = "neura.fmul_fadd"(%a, %b, %c) : (f32, f32, f32) -> f32
-  // CHECK: [neura-interpreter]  → Output: 0.000000
-  return %res : f32
 }
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/phi.mlir b/test/neura/interpreter/basic_operation/phi.mlir
index 1e3f00d9..3ccd889e 100644
--- a/test/neura/interpreter/basic_operation/phi.mlir
+++ b/test/neura/interpreter/basic_operation/phi.mlir
@@ -11,7 +11,7 @@ func.func @test_phi_ctrlflow() -> f32 {
   "neura.ctrl_mov"(%one, %v) : (f32, f32) -> ()
 
   %cond = arith.constant 0 : i1
-  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^bb1:
   "neura.ctrl_mov"(%init, %v) : (f32, f32) -> ()
@@ -44,7 +44,7 @@ func.func @test_loop_phi() -> f32 {
 
   %cond = "neura.fcmp"(%i, %limit) {cmpType = "lt"} : (f32, f32) -> i1
 
-  "neura.cond_br"(%cond) [^loop_body, ^loop_exit] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  "neura.cond_br"(%cond) [^loop_body, ^loop_exit] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^loop_body:
   %i_next = "neura.fadd"(%i, %one) : (f32, f32) -> f32
@@ -63,8 +63,8 @@ func.func @test_phi_multi_preds() -> i32 {
   %c0 = arith.constant 0 : i32
   %c1 = arith.constant 1 : i32
   %c2 = arith.constant 2 : i32
-  %cond = arith.constant 0 : i1  
-  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  %cond = arith.constant 0 : i1
+  "neura.cond_br"(%cond) [^bb1, ^bb2] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^bb1:
   "neura.br"() [^merge] : () -> ()
@@ -102,7 +102,7 @@ func.func @test_small_nested_loops() -> f32 {
 ^outer_head:
   %i = "neura.phi"(%outer_i, %zero) : (f32, f32) -> f32
   %outer_cond = "neura.fcmp"(%i, %two) {cmpType = "lt"} : (f32, f32) -> i1
-  "neura.cond_br"(%outer_cond) [^outer_body, ^outer_exit] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  "neura.cond_br"(%outer_cond) [^outer_body, ^outer_exit] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^outer_body:
   %inner_j = "neura.reserve"() : () -> f32
@@ -114,7 +114,7 @@ func.func @test_small_nested_loops() -> f32 {
 ^inner_head:
   %j = "neura.phi"(%inner_j, %zero) : (f32, f32) -> f32
   %inner_cond = "neura.fcmp"(%j, %two) {cmpType = "lt"} : (f32, f32) -> i1
-  "neura.cond_br"(%inner_cond) [^inner_body, ^inner_exit] {operandSegmentSizes = array<i32: 1, 0, 0, 0>} : (i1) -> ()
+  "neura.cond_br"(%inner_cond) [^inner_body, ^inner_exit] {operandSegmentSizes = array<i32: 1, 0, 0>} : (i1) -> ()
 
 ^inner_body:
   %i_mul_two = "neura.fmul"(%i, %two) : (f32, f32) -> f32
diff --git a/test/neura/interpreter/basic_operation/predicated_data.mlir b/test/neura/interpreter/basic_operation/predicated_data.mlir
index f72670a1..8d6c512f 100644
--- a/test/neura/interpreter/basic_operation/predicated_data.mlir
+++ b/test/neura/interpreter/basic_operation/predicated_data.mlir
@@ -1,11 +1,11 @@
 // RUN: neura-interpreter %s | FileCheck %s
 
 module {
-  func.func @test() -> !neura.data<f32, i1> {
-    %arg0 = "neura.constant"() <{value = 9.0 : f32, predicate = true}> : () -> !neura.data<f32, i1>
-    %cst = "neura.constant"() <{value = 2.0 : f32, predicate = false}> : () -> !neura.data<f32, i1>
-    %res = "neura.fadd"(%arg0, %cst) : (!neura.data<f32, i1>, !neura.data<f32, i1>) -> !neura.data<f32, i1>
-    return %res : !neura.data<f32, i1>
-    // CHECK: [neura-interpreter]  → Output: 0.000000
+  func.func @test() -> f32 {
+    %arg0 = "neura.constant"() {value = 9.0 : f32} : () -> f32
+    %cst = "neura.constant"() {value = 2.0 : f32} : () -> f32
+    %res = "neura.fadd"(%arg0, %cst) : (f32, f32) -> f32
+    return %res : f32
+    // CHECK: [neura-interpreter]  → Output: 11.000000
   }
 }
diff --git a/test/neura/interpreter/basic_operation/sub.mlir b/test/neura/interpreter/basic_operation/sub.mlir
index a5047488..3cf3b11e 100644
--- a/test/neura/interpreter/basic_operation/sub.mlir
+++ b/test/neura/interpreter/basic_operation/sub.mlir
@@ -20,25 +20,11 @@ func.func @test_sub_negative() -> i32 {
   return %res : i32
 }
 
-// TODO: Remove tests with predicate input because we plan to remove the predicate attribute in
-// https://github.com/coredac/dataflow/issues/116
-
 // Test subtraction with predicate=true
-// func.func @test_sub_with_predicate_true() -> i32 {
-//   %a = arith.constant 300 : i32
-//   %b = arith.constant 100 : i32
-//   %pred = arith.constant 1 : i32  
-//   %res = "neura.sub"(%a, %b, %pred) : (i32, i32, i32) -> i32
-
-//   return %res : i32
-// }
-
-
-// Test subtraction with predicate=false
-// func.func @test_sub_with_predicate_false() -> i32 {
-//   %a = arith.constant 500 : i32
-//   %b = arith.constant 200 : i32
-//   %pred = arith.constant 0 : i32  
-//   %res = "neura.sub"(%a, %b, %pred) : (i32, i32, i32) -> i32
-//   return %res : i32
-// }
\ No newline at end of file
+func.func @test_sub_with_embed_predicate_true() -> i32 {
+  %a = "neura.constant"() {value = 300 : i32} : () -> i32
+  %b = "neura.constant"() {value = 100 : i32} : () -> i32
+  %res = "neura.sub"(%a, %b) : (i32, i32) -> i32
+  // CHECK: [neura-interpreter]  → Output: 200.000000
+  return %res : i32
+}
\ No newline at end of file
diff --git a/test/neura/interpreter/basic_operation/vfmul.mlir b/test/neura/interpreter/basic_operation/vfmul.mlir
index bf807366..2c1c425a 100644
--- a/test/neura/interpreter/basic_operation/vfmul.mlir
+++ b/test/neura/interpreter/basic_operation/vfmul.mlir
@@ -4,20 +4,16 @@ func.func @test_vfmul_basic() -> vector<2xf32> {
   %a = "neura.constant"() {value = dense<[2.0, 3.0]> : vector<2xf32>} : () -> vector<2xf32>
   %b = "neura.constant"() {value = dense<[4.0, 5.0]> : vector<2xf32>} : () -> vector<2xf32>
   %res = "neura.vfmul"(%a, %b) : (vector<2xf32>, vector<2xf32>) -> vector<2xf32>
-  
+
   // CHECK: [neura-interpreter]  → Output: [8.000000, 15.000000]
-  
+
   return %res : vector<2xf32>
 }
 
-func.func @test_vfmul_with_valid_predicate() -> vector<3xf32> {
-  %a = "neura.constant"() {value = dense<[6.0, 7.0, 8.0]> : vector<3xf32>} : () -> vector<3xf32>
-  %b = "neura.constant"() {value = dense<[0.5, 2.0, 0.1]> : vector<3xf32>} : () -> vector<3xf32>
-  %pred = arith.constant 0 : i1
-  %pred_as_f32 = "neura.cast"(%pred) {cast_type = "bool2f"} : (i1) -> f32
-  %res = "neura.vfmul"(%a, %b, %pred_as_f32) : (vector<3xf32>, vector<3xf32>, f32) -> vector<3xf32>
-  
-  // CHECK: [neura-interpreter]  → Output: [0.000000, 0.000000, 0.000000]
-  
-  return %res : vector<3xf32>
-}
\ No newline at end of file
+// func.func @test_vfmul_with_invalid_embed_predicate() -> vector<3xf32> {
+//   %a = "neura.constant"() {value = dense<[6.0, 7.0, 8.0]> : vector<3xf32>, predicate = false} : () -> vector<3xf32>
+//   %b = "neura.constant"() {value = dense<[0.5, 2.0, 0.1]> : vector<3xf32>, predicate = false} : () -> vector<3xf32>
+//   %res = "neura.vfmul"(%a, %b) : (vector<3xf32>, vector<3xf32>) -> vector<3xf32>
+//   // [neura-interpreter]  → Output: [0.000000, 0.000000, 0.000000]
+//   return %res : vector<3xf32>
+// }
\ No newline at end of file
diff --git a/tools/neura-interpreter/neura-interpreter.cpp b/tools/neura-interpreter/neura-interpreter.cpp
index 4d2803c5..96405e0f 100644
--- a/tools/neura-interpreter/neura-interpreter.cpp
+++ b/tools/neura-interpreter/neura-interpreter.cpp
@@ -389,6 +389,10 @@ bool handleNeuraConstantOp(
     assert(value_to_predicated_data_map.count(op.getResult()) == 0 &&
            "Duplicate constant result?");
     value_to_predicated_data_map[op.getResult()] = val;
+    if (isVerboseMode()) {
+      llvm::outs() << "[neura-interpreter]  └─ Constant  : value = " << val.value
+                  << " [pred = " << val.predicate << "]\n";
+    }
   }
   // Handles integer scalar constants.
   else if (auto int_attr = llvm::dyn_cast<mlir::IntegerAttr>(attr)) {
@@ -404,6 +408,10 @@ bool handleNeuraConstantOp(
     assert(value_to_predicated_data_map.count(op.getResult()) == 0 &&
            "Duplicate constant result?");
     value_to_predicated_data_map[op.getResult()] = val;
+    if (isVerboseMode()) {
+      llvm::outs() << "[neura-interpreter]  └─ Constant  : value = " << val.value
+                  << " [pred = " << val.predicate << "]\n";
+    }
   }
   // Handles vector constants (dense element attributes).
   else if (auto dense_attr = llvm::dyn_cast<mlir::DenseElementsAttr>(attr)) {
@@ -435,6 +443,7 @@ bool handleNeuraConstantOp(
     value_to_predicated_data_map[op.getResult()] = val;
 
     if (isVerboseMode()) {
+      llvm::outs() << "[neura-interpreter]  ├─ Constant  : pred = " << val.predicate << "]\n";
       llvm::outs() << "[neura-interpreter]  └─ Parsed vector constant of size: "
                    << vector_size << "\n";
     }
@@ -1783,15 +1792,15 @@ bool handleCastOp(
   if (isVerboseMode()) {
     llvm::outs() << "[neura-interpreter]  Executing neura.cast:\n";
   }
-  if (op.getNumOperands() < 1 || op.getNumOperands() > 2) {
+  if (op.getOperation()->getNumOperands() != 1) {
     if (isVerboseMode()) {
       llvm::errs()
-          << "[neura-interpreter]  └─ neura.cast expects 1 or 2 operands\n";
+          << "[neura-interpreter]  └─ neura.cast expects 1 operand\n";
     }
     return false;
   }
 
-  auto input = value_to_predicated_data_map[op.getOperand(0)];
+  auto input = value_to_predicated_data_map[op.getOperand()];
   std::string cast_type = op.getCastType().str();
 
   if (isVerboseMode()) {
@@ -1801,23 +1810,13 @@ bool handleCastOp(
   }
 
   bool final_predicate = input.predicate;
-  if (op.getOperation()->getNumOperands() > 1) {
-    auto pred_operand = value_to_predicated_data_map[op.getOperand(1)];
-    final_predicate = final_predicate && pred_operand.predicate &&
-                      (pred_operand.value != 0.0f);
-    if (isVerboseMode()) {
-      llvm::outs() << "[neura-interpreter]  ├─ Execution Context\n";
-      llvm::outs() << "[neura-interpreter]  │  └─ Pred      : value = "
-                   << pred_operand.value
-                   << ", [pred = " << pred_operand.predicate << "]\n";
-    }
-  }
   if (isVerboseMode()) {
+    llvm::outs() << "[neura-interpreter]  ├─ Execution Context\n";
     llvm::outs() << "[neura-interpreter]  ├─ Cast type : " << cast_type << "\n";
   }
 
   float result_value = 0.0f;
-  auto input_type = op.getOperand(0).getType();
+  auto input_type = op.getOperand().getType();
   // Handles specific conversion types with input type validation.
   if (cast_type == "f2i") {
     if (!input_type.isF32()) {
@@ -2242,18 +2241,11 @@ bool handleCondBrOp(
   // Computes final predicate (combines condition's predicate and optional
   // predicate operand).
   bool final_predicate = cond_data.predicate;
-  if (op.getNumOperands() > 1) {
-    auto pred_data = value_to_predicated_data_map[op.getPredicate()];
-    final_predicate =
-        final_predicate && pred_data.predicate && (pred_data.value != 0.0f);
-    if (isVerboseMode()) {
-      llvm::outs() << "[neura-interpreter]  ├─ Execution Context\n";
-      llvm::outs() << "[neura-interpreter]  │  └─ Pred : value = "
-                   << pred_data.value << " [pred = " << pred_data.predicate
-                   << "]\n";
-    }
+  if (isVerboseMode()) {
+    llvm::outs() << "[neura-interpreter]  ├─ Execution Context\n";
   }
 
+
   // Retrieves successor blocks (targets of the conditional branch).
   auto current_succs_range = current_block->getSuccessors();
   std::vector<Block *> succ_blocks(current_succs_range.begin(),