public abstract class BlockPayload {
    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();

};

// Checks if `op` is nested in `block`.
bool OpInBlock(Operation* op, Block* block) {
  Block* op_block = op->getBlock();
  while (op_block) {
    if (op_block == block) return true;
    if (auto* parent_op = op_block->getParentOp()) {
      op_block = parent_op->getBlock();
    } else {
      break;
    }
  }
  return false;
}

                   const NamedAttrList& attrs) {
  if (begin->getBlock() == end->getBlock()) {
    AddAttributesInSameBlock(begin, end, attrs);
  } else {
    Region::iterator begin_block = Region::iterator(begin->getBlock());
    Region::iterator end_block = Region::iterator(end->getBlock());
    AddAttributesInSameBlock(begin, begin_block->end(), attrs);

        nextBlock = 0;
    }

    @Override
    public void attach(BlockPayload block) {
        if (block.getBlock() == null) {
            block.setBlock(new BlockImpl(block));
        }
    }

    @Override
    public void remove(BlockPayload block) {
        BlockImpl blockImpl = (BlockImpl) block.getBlock();
        blockImpl.detach();
    }

    @Override
    public void flush() {
    }

      .def("getContext", &mlir::OpBuilder::getContext,
           py::return_value_policy::reference);

  py::class_<mlir::OpBuilder::InsertPoint>(m, "OpBuilder_InsertionPoint")
      .def("getBlock", &mlir::OpBuilder::InsertPoint::getBlock);

           .DirectControlPredecessors(
               to_merge,
               [&c](Operation* pred) {
                 Operation* const last_c_op = c.ops.back();
                 return last_c_op->getBlock() == pred->getBlock() &&
                        last_c_op->isBeforeInBlock(pred);
               })
           .empty();
  if (has_control_predecessors_after_cluster) {
    return false;
  }

                 const TF::SideEffectAnalysis::Info& side_effect_analysis) {
  // IfRegion ops must be in the same block.
  if (second_if.getOperation()->getBlock() !=
      first_if.getOperation()->getBlock()) {
    return false;
  }
  assert(first_if.getOperation()->isBeforeInBlock(second_if.getOperation()));

  llvm::SmallSetVector<Operation*, 4> destination_ops =

    assert(op && "member operation must be not null");

    for (Operation *user : op->getUsers()) {
      // Skip users in other blocks.
      if (user->getBlock() != op->getBlock()) continue;

      // Skip users is in the `dst_root` or `src_root` clusters, if we'll merge
      // roots they'll become a single cluster and will not violate the
      // dominance property after that.

  auto* resource_handle_op = assign_var.getResource().getDefiningOp();
  if (resource_handle_op == parallel_execute) return nullptr;

  if (resource_handle_op &&
      resource_handle_op->getBlock() ==
          parallel_execute.getOperation()->getBlock() &&
      parallel_execute.getOperation()->isBeforeInBlock(resource_handle_op))
    return nullptr;

  return assign_var;
}

        store.close();
    }

    @Override
    public void clear() {
        store.clear();
    }

    @Override
    public void remove(BlockPayload block) {
        Block container = block.getBlock();
        store.remove(block);
        freeListBlock.add(container.getPos(), container.getSize());
    }

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