Block &block = body.front();
    for (const auto &arg_mapping :
         llvm::zip(block.getArguments(), op->getOperands())) {
      std::get<0>(arg_mapping).replaceAllUsesWith(std::get<1>(arg_mapping));
    }
    op->getBlock()->getOperations().splice(op->getIterator(),
                                           block.getOperations(), block.begin(),
                                           std::prev(block.end()));

    if (args_permutation.empty() || res_permutation.empty()) return;

    mlir::Operation* op = layout_sensitive_interface.getOperation();
    Location loc = op->getLoc();
    OpBuilder builder = OpBuilder::atBlockEnd(op->getBlock());

    auto perm_attr = [&](Permutation permutation) -> DenseIntElementsAttr {
      auto perm_ty = RankedTensorType::get({4}, builder.getIntegerType(64));
      return DenseIntElementsAttr::get(perm_ty, permutation);

func (tw *Writer) Flush() error {
	if tw.err != nil {
		return tw.err
	}
	if nb := tw.curr.logicalRemaining(); nb > 0 {
		return fmt.Errorf("archive/tar: missed writing %d bytes", nb)
	}
	if _, tw.err = tw.w.Write(zeroBlock[:tw.pad]); tw.err != nil {
		return tw.err
	}
	tw.pad = 0
	return nil
}

// WriteHeader writes hdr and prepares to accept the file's contents.

      if (mlir::dyn_cast_or_null<BlockArgument>(operand)) continue;
      auto operand_op = operand.getDefiningOp();
      if (IsConstant(operand_op)) continue;
      if (operand_op->getBlock() != op->getBlock()) {
        return WalkResult::interrupt();
      }
    }
    return WalkResult::advance();
  });
  return !walk_result.wasInterrupted();
}

// It reduces the following pattern:
//

	defineLink(label string, link *Link)
	newText(pos Position, text string) *Text
}

type blockBuilder interface {
	extend(p *parseState, s line) (line, bool)
	build(buildState) Block
}

type openBlock struct {
	builder blockBuilder
	inner   []Block
	pos     Position
}

type itemBuilder struct {
	list        *listBuilder
	width       int
	haveContent bool
}

func (p *parseState) last() Block {

    int incoming_ctrl_edges = 0;
    int incoming_data_edges = 0;
    op.walk([&](Operation* child) {
      ancestor[child] = &op;
      for (Operation* predecessor : ctrlPredecessors(child)) {
        if (predecessor->getBlock() == &block) {
          incoming_ctrl_edges++;
        }
      }
      for (Value v : child->getOperands()) {
        if (v.getParentBlock() == &block) {
          incoming_data_edges++;
        }
      }

    return failure();

  // Move all inner ops of the launch to the block containing the launch.
  auto body = launch.GetBody().without_terminator();
  Operation* launch_op = launch.getOperation();
  launch_op->getBlock()->getOperations().splice(
      launch_op->getIterator(), launch.GetBody().getOperations(), body.begin(),
      body.end());

  launch.erase();

  return success();
}

  Value cond_i1 = LowerCondition(loc, op.getCond(), &builder);
  if (!cond_i1) return failure();

  // Split the basic block before the 'if'.  The new dest will be our merge
  // point.
  Block* orig_block = op_inst->getBlock();
  Block* merge_block = orig_block->splitBlock(op);

  // Add the block arguments to the merge point, and replace all uses of the
  // original operation results with them.
  for (Value value : op_inst->getResults())

            input.getDefiningOp());
      }))
    return replicated_input.emitOpError()
           << "expects all inputs from 'tf.TPUPartitionedInputV2' ops";

  const auto metadata_iter =
      replicated_input->getBlock()->getOps<TF::TPUReplicateMetadataOp>();
  TF::TPUReplicateMetadataOp metadata;
  if (!metadata_iter.empty()) metadata = *(metadata_iter.begin());

  auto first_partitioned_input = llvm::cast<TF::TPUPartitionedInputV2Op>(

				if tc.fsVolume {
					if capability.GetMount() == nil {
						t.Errorf("For %s: expected mount accesstype got: %v", tc.name, capability)
					}
				} else {
					if capability.GetBlock() == nil {
						t.Errorf("For %s: expected block accesstype got: %v", tc.name, capability)
					}
				}
			}
		})
	}
}

func TestNodeExpandNoClientError(t *testing.T) {