initializes the TF EagerContext and returns an output chain.

    Example:
      %c1 = "tfd.init_eager_context"(%c0): (!tfrt.chain) -> !tfrt.chain
  }];

  let arguments = (ins TFRT_ChainType);
  let results = (outs TFRT_ChainType);
}

def DelegateKernelOp : RuntimeFallbackDialect_Op<"delegate_kernel"> {
  let summary = "delegate kernel operation";
  let description = [{

				}
				this.get_container().html("<ul><li class='jstree-last jstree-leaf'><ins>&#160;</ins><a class='jstree-loading' href='#'><ins class='jstree-icon'>&#160;</ins>" + this._get_string("loading") + "</a></li></ul>");
				this.data.core.li_height = this.get_container_ul().find("li.jstree-closed, li.jstree-leaf").eq(0).height() || 18;

				this.get_container()
					.delegate("li > ins", "click.jstree", $.proxy(function (event) {
							var trgt = $(event.target);

  let description = [{
    Transfer a CPU tensor to device.

    Example:
      %device_tensor = gpurt.transfer_to_device %cpu_tensor
  }];

  let arguments = (ins TFTensorType);
  let results = (outs TFTensorType);
  let assemblyFormat = "operands attr-dict";
}

// TODO(b/260267885): We may add a device argument when we want to support
// GPU MIG.

    The non-control operands of the fetch operation are returned outside of the
    graph and must match the return type of the graph.
  }];

  let arguments = (ins
    Variadic<AnyType>:$fetches
  );

  let builders = [
    OpBuilder<(ins),
    [{
      build($_builder, $_state, {});
    }]>
   ];

  let assemblyFormat = "($fetches^ `:` type($fetches))? attr-dict";

  let hasVerifier = 0;

    Await a tensor from a !mlrt.future.

    $future: A value of type !mlrt.future. The underlying value must be a tensorflow tensor.

    $result: a tensorflow tensor.
  }];

  let arguments = (ins
    MlrtFutureType:$future
  );

  let results = (outs
    TF_Tensor:$result
  );
}

// tf_mlrt.tf_promise takes a tensorflow Tensor. It is a fake op that is only

    private val directDependentsByKtModule: Map<KtModule, Set<KtModule>> by lazy {
        // Direct dependencies should be computed lazily, because the built-ins module will be reachable via module dependencies. Getting
        // the built-ins module relies on the built-ins session, which may depend on services that are registered after
        // `KtStaticModuleDependentsProvider`.
        buildDependentsMap(modules) { it.allDirectDependencies() }

		for _, ent := range tt.ents {
			testStaticHost(t, tt.name, ent)
		}
	}
}

func testStaticHost(t *testing.T, hostsPath string, ent staticHostEntry) {
	ins := []string{ent.in, absDomainName(ent.in), strings.ToLower(ent.in), strings.ToUpper(ent.in)}
	for _, in := range ins {
		addrs, _ := lookupStaticHost(in)
		if !reflect.DeepEqual(addrs, ent.out) {
			t.Errorf("%s, lookupStaticHost(%s) = %v; want %v", hostsPath, in, addrs, ent.out)
		}

for portability. The following code defines the semantics of `AddNOp`:

```python
@Composite('AddNOp')
def _my_op_c(ins):
  N = len(ins)
  if N == 1:
    return ins[0]
  sum = ins[0]
  for i in range(1, N):
    sum += ins[i]
  return sum
```

Utilities have been built to compile the Python composition functions down to

	if err := os.Mkdir(outdir, 0777); err != nil {
		t.Fatalf("can't create outdir %s: %v", outdir, err)
	}

	// Merge the two dirs into a final result.
	ins := fmt.Sprintf("-i=%s,%s", indir1, indir2)
	out := fmt.Sprintf("-o=%s", outdir)
	margs := []string{ins, out}
	lines := runToolOp(t, s, "merge", margs)
	if len(lines) != 0 {
		t.Errorf("merge run produced %d lines of unexpected output", len(lines))
		dumplines(lines)

  let printer = "$_printer << '[' << $_self << ']'";
}

def DimensionMetadataAttr : AttrDef<TFL_Dialect, "DimensionMetadata"> {
  let mnemonic = "dimension_metadata";
  let parameters = (ins
      TFL_DimensionTypeAttr:$format,
      "int32_t":$dense_size,
      I32ArrayParameter:$segments,
      I32ArrayParameter:$indices
  );
  let summary = "Dimension metadata.";