__msg_length uint32
		__msg        uintptr
		_            [4]uint8
	}
	msg := fmt.Sprintf(format, v...)
	strptr := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&msg)).Data)
	len := (*reflect.StringHeader)(unsafe.Pointer(&msg)).Len
	cmsg := __cmsg{__msg_length: uint32(len), __msg: uintptr(strptr)}
	cmd := uint32(0)
	runtime.EnterSyscall()

-# define strstr(haystack, needle) \
-  (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \
-		  ? (((const char *) (needle))[0] == '\0'		      \
-		     ? (char *) (size_t) (haystack)			      \
-		     : (((const char *) (needle))[1] == '\0'		      \
-			? strchr (haystack,				      \
-				  ((const char *) (needle))[0]) 	      \
-			: strstr (haystack, needle)))			      \

          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),

    StrAttr:$output_file_path,
    StrArrayAttr:$ids,
    I32ArrayAttr:$calibration_methods
  );

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;
}

def TF_DumpTensorOp : TF_Op<"DumpTensor", []> {
  let summary = "Dump tensor proto.";

  let arguments = (ins
    Arg<TF_Tensor>:$input,

    StrAttr:$log_dir_path,
    StrAttr:$file_name,

  }];

  let arguments = (ins
    TFRT_ChainType:$in_ch,
    I64Attr:$num_args,
    StrAttr:$device,
    ArrayAttr:$op_attrs,
    // TODO(b/173025975): consider using DictionaryAttr after we support
    // BEF conversion for this type.
    ArrayAttr:$op_func_attrs,
    I64Attr:$op_key,
    StrAttr:$op_name
  );

  let results = (outs
    TFRT_ChainType:$out_ch
  );

  }];
  let arguments = (ins
    Variadic<TFTensorType>:$operands_and_static_shapes,
    DenseI32ArrayAttr:$constant_operand_indices,
    StrAttr:$metadata,
    StrAttr:$mlir_module,
    UI32Attr:$num_operands,
    DenseI32ArrayAttr:$operands_with_static_shape,
    StrAttr:$producer_name
  );

  let results = (outs
    TFTensorType:$rendezvous_key_base,
    Variadic<MlrtFutureType>:$results
  );

underlying graph, and executes each of the partitioned subgraphs as a function.
  }];

  let arguments = (ins
    Variadic<TF_Tensor>:$args,

    FlatSymbolRefAttr:$f,
    StrAttr:$config,
    StrAttr:$config_proto,
    StrAttr:$executor_type
  );

  let results = (outs
    Variadic<TF_Tensor>:$output
  );

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;

  }];

  let arguments = (ins
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let assemblyFormat = "attr-dict";
}

def ConstOp: TensorflowMlrt_Op<"constop", []> {
  let summary = "The tf_mlrt ConstOp";

  let description = [{
    The ConstOp creates a constant tensorflow::Tensor from serialized proto.
  }];

  let arguments = (ins
    StrAttr:$tensor_proto
  );

  let results = (outs

  let summary = "Send a value to a host.";

  let description = [{
    Send the value to the given host with the given rendezvous key.
  }];

  let arguments = (ins
    AnyType:$value,
    StrAttr:$key,
    StrAttr:$dst_host
  );

  let results = (outs);

  let assemblyFormat = [{$value $key $dst_host attr-dict `:` type($value)}];
}

def TfDevice_ReceiveOp : TfDevice_Op<"receive", []> {

def LegalizeAvgPool2dComposite: Pat<
                    (MHLO_CompositeOp:$old_val
                    (variadic $a_input), 
                    ConstantStrAttr<StrAttr, "aten.avg_pool2d.default">, $attrs, $_, $_),
                    (TFL_TransposeOp 
                        (TFL_AveragePool2DOp 
                            /*input*/ (TFL_TransposeOp $a_input,