for (auto var_handle_op : var_handle_ops) {
    tensor_names.emplace_back(var_handle_op.getSharedName().str());

    auto read_var_op = builder.create<TF::ReadVariableOp>(
        var_handle_op.getLoc(), var_handle_op.resource_subtype(),
        var_handle_op);
    tensor_values.emplace_back(read_var_op.getResult());
  }

  TF::ConstOp tensor_names_const =
      CreateTensorNamesConst(tensor_names, builder);

  llvm::SmallVector<Value, 1> control_tokens;
  for (auto *op : ops_with_side_effects) {
    // Wrap all side-effect producing/dependent operations in a ControlNodeOp.
    builder.setInsertionPoint(op);
    Location loc = op->getLoc();
    auto outer_op = builder.create<ControlNodeOp>(
        loc, op->getResultTypes(), ControlType::get(op->getContext()),
        control_tokens);
    Region region;
    Block *new_block = new Block;

           << "references an unknown entry function " << entry_func_symbol;
  }

  OpBuilder builder(module.getContext());

  OwningOpRef<ModuleOp> stablehlo_module =
      builder.create<ModuleOp>(op.getLoc());
  builder.setInsertionPointToEnd(stablehlo_module->getBody());

  // Copy all referenced StableHLO functions to the new module.
  WalkResult result = WalkReachableFunctions(
      entry_func,

    if (!erase[result.getResultNumber()]) {
      result_types.push_back(result.getType());
    }
  }
  OpBuilder builder(op);
  builder.setInsertionPointAfter(op);
  OperationState state(op->getLoc(), op->getName().getStringRef(),
                       op->getOperands(), result_types, op->getAttrs());
  for (int i = 0; i < op->getNumRegions(); ++i) {
    state.addRegion();
  }

    public void attach(BlockPayload block) {
        store.attach(block);
    }

    @Override
    public void remove(BlockPayload block) {
        dirty.remove(block.getPos());
        if (isCacheable(block)) {
            indexBlockCache.invalidate(block.getPos());
        }
        store.remove(block);
    }

    @Override
    public <T extends BlockPayload> T readFirst(Class<T> payloadType) {

                @Inject abstract ProviderFactory getProviderFactory()

                @Internal abstract Property<String> getOther()

                @Internal Provider<String> getFoo() {
                    return other;
                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }

            assert newPayloadSize >= payloadSize;
            payloadSize = newPayloadSize;
        }

        public void write() throws Exception {
            long pos = getPos().getPos();

            DataOutputStream outputStream = output.start(pos);

            BlockPayload payload = getPayload();

            // Write header
            outputStream.writeByte(payload.getType());

    }

    public abstract BlockPointer getPos();

    public abstract int getSize();

    public abstract RuntimeException blockCorruptedException();

    @Override
    public String toString() {
        return payload.getClass().getSimpleName() + " " + getPos();
    }

    public BlockPointer getNextPos() {
        return BlockPointer.pos(getPos().getPos() + getSize());
    }

    private Block block;

    public Block getBlock() {
        return block;
    }

    public void setBlock(Block block) {
        this.block = block;
    }

    public BlockPointer getPos() {
        return getBlock().getPos();
    }

    public BlockPointer getNextPos() {
        return getBlock().getNextPos();
    }

    protected abstract int getSize();

    protected abstract byte getType();

	g := Gcd(x, y)
	fmt.Println("The gcd of", x, "and", y, "is", g)

	// Manipulate the Foo global variable

	// Output its current value
	fmt.Println("Foo =", GetFoo())

	// Change its value
	SetFoo(3.1415926)

	// See if the change took effect
	fmt.Println("Foo =", GetFoo())
}
-- main.swig --
%module main

%inline %{
extern int    gcd(int x, int y);
extern double Foo;
%}
-- main_test.go --
package main