builder_.setInsertionPointAfter(op);
  const Value original_result = op->getResult(result_index);
  QuantizeValue(original_result, quantized_type, op->getLoc());
}

void QuantizationDriver::QuantizeArg(BlockArgument arg,
                                     const QuantizedType quantized_type) {
  builder_.setInsertionPointToStart(arg.getOwner());

    indices_type = RankedTensorType::get(new_start_indices_shape,
                                         indices_type.getElementType());
    indices = rewriter.create<mhlo::ReshapeOp>(parent_op->getLoc(),
                                               indices_type, indices);
  } else if (index_vector_dim != indices_type.getRank() - 1) {
    // If index_vector_dim isn't the last dimension in indices then it isn't

    if (existing) return *existing;
  }

  ModuleOp module = region.getParentOfType<ModuleOp>();
  OpBuilder builder(module.getContext());
  auto loc = region.getParentOp()->getLoc();
  Block& entry = region.front();
  int num_region_arguments = entry.getNumArguments();
  Operation* terminator = entry.getTerminator();

  // Build the function type. Region arguments and extern values together

     * <code>"info"</code>, <code>"warn"</code>, and <code>"error"</code>.
     * @deprecated Use SLF4J directly
     */
    @Deprecated
    Log getLog();

  std::unique_ptr<llvm::MemoryBuffer> mem_buffer;
  llvm::StringRef quantized_function_library =
      GetFunctionLibrary(quantization_method_, op_set_);

  if (quantized_function_library.empty()) {
    emitError(module.getLoc())
        << "Failed to get function library for the opset.";
    signalPassFailure();
    return;
  }

  mem_buffer =
      llvm::MemoryBuffer::getMemBuffer(quantized_function_library,

    /**
     * @return the sessionFlags
     */
    public int getSessionFlags () {
        return this.sessionFlags;
    }


    /**
     * @return security blob
     */
    public byte[] getBlob () {
        return this.blob;
    }

    protected final String sourceClass;

    protected final Log logger;

    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);

           py::return_value_policy::reference)
      .def("end", &mlir::Block::end)
      .def("addArgument", [](mlir::Block& block, mlir::Type type) {
        return block.addArgument(type, block.getParent()->getLoc());
      });

  py::class_<mlir::Value>(m, "Value").def("getType", &mlir::Value::getType);
  py::class_<mlir::OpResult, mlir::Value>(m, "OpResult");
  py::class_<mlir::BlockArgument, mlir::Value>(m, "BlockArgument");

                                                    TypeRange(types), result);
      new_forward_ops.insert(replicated_output);
      // TODO(bfontain): Check for other attributes.
      replicated_output->setAttr(kDevice, builder.getStringAttr(""));
      TF::TPUReplicatedInputOp input = builder.create<TF::TPUReplicatedInputOp>(

     * @return the isLoggedInAsGuest
     */
    public final boolean isLoggedInAsGuest () {
        return this.isLoggedInAsGuest;
    }


    /**
     * @return the blob
     */
    public final byte[] getBlob () {
        return this.blob;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override