core_to_host_insertion_point[0], core_to_compilation_key[0],
      core_to_device_ordinal.empty() ? nullptr : core_to_device_ordinal[0],
      device_type_attr, builder, op, std::move(args_communication_key),
      std::move(retvals_communication_key), host0_ops);

  if (external_operands.empty()) {
    recv_at_host->erase();
  } else {
    ReplaceExternalOperandUsage(
        external_operands, recv_at_host,

  options.session_options = &session_options;
  options.flib_def = flib_def;
  TF_RETURN_IF_ERROR(s.ToGraph(graph.get()));
  ForceXlaConstantsOnHostPass rewriter;
  TF_RETURN_IF_ERROR(rewriter.Run(options));
  *result = std::move(graph);
  return absl::OkStatus();
}

TEST(ForceXlaConstantsOnHostPassTest, Simple) {
  GraphDefBuilder b(GraphDefBuilder::kFailImmediately);
  Scope root = Scope::NewRootScope().ExitOnError();

set -exo pipefail

function is_continuous_or_release() {
  [[ "$KOKORO_JOB_TYPE" == "CONTINUOUS_INTEGRATION" ]] || [[ "$KOKORO_JOB_TYPE" == "RELEASE" ]]
}

# Move into the directory of the script
cd "$(dirname "$0")"

if is_continuous_or_release || [[ -z "$KOKORO_BUILD_ID" ]]; then
  # A continuous job is the only one to publish to latest
  TAG="latest-multi-python"
else

	AFADDS
	AFSUBS
	AFMULS
	AFDIVS
	AFMINS
	AFMAXS
	AFSQRTS
	AFMADDS
	AFMSUBS
	AFNMADDS
	AFNMSUBS

	// 11.7: Single-Precision Floating-Point Conversion and Move Instructions
	AFCVTWS
	AFCVTLS
	AFCVTSW
	AFCVTSL
	AFCVTWUS
	AFCVTLUS
	AFCVTSWU
	AFCVTSLU
	AFSGNJS
	AFSGNJNS
	AFSGNJXS
	AFMVXS
	AFMVSX
	AFMVXW
	AFMVWX

	ANOALG         // implies ANOEQ, and in addition has a part that is marked Noalg
	AMEM           // Type can be compared/hashed as regular memory.
	AMEM0          // Specific subvariants of AMEM (TODO: move to ../reflectdata?)
	AMEM8
	AMEM16
	AMEM32
	AMEM64
	AMEM128
	ASTRING
	AINTER
	ANILINTER
	AFLOAT32
	AFLOAT64
	ACPLX64
	ACPLX128
	ASPECIAL // Type needs special comparison/hashing functions.
)

      llvm::errs() << "Can't get llvm::MemoryBuffer\n";
      return "";
    }
  }

  mlir::MLIRContext context;
  context.printOpOnDiagnostic(true);
  llvm::SourceMgr sourceMgr;
  sourceMgr.AddNewSourceBuffer(std::move(input), llvm::SMLoc());

  mlir::OwningOpRef<mlir::ModuleOp> module =
      FlatBufferFileToMlirTranslation(&sourceMgr, &context);
  if (!module || failed(verify(*module))) return "";

  std::string mlir_output;

  } else {
    patterns.add<TFLFullQuantization, TFLFullQuantizationReverse>(ctx,
                                                                  quant_params);
  }
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));

  // Constant quantization is a lossy transformation, so they are applied only
  // after all the other patterns have been aplied.
  RewritePatternSet patterns_2(&getContext());

Value CloneGraphOps(GraphOp src_graph_op, GraphOp dst_graph_op,
                    IRMapping& mapper) {
  Block& main_body = dst_graph_op.GetBody();

  // Take the reference of the main graph's FetchOp to later move to the end.
  FetchOp main_fetch_op = dst_graph_op.GetFetch();

  Block& save_func_body = src_graph_op.GetBody();
  for (Operation& op : save_func_body.without_terminator()) {
    main_body.push_back(op.clone(mapper));

	/* copy arguments to stack */		\
	MOVV	arg+16(FP), R4;			\
	MOVWU	argsize+24(FP), R5;			\
	MOVV	R3, R12;				\
	ADDV	$8, R12;			\
	ADDV	R12, R5;				\
	BEQ	R12, R5, 6(PC);				\
	MOVBU	(R4), R6;			\
	ADDV	$1, R4;			\
	MOVBU	R6, (R12);			\
	ADDV	$1, R12;			\
	JMP	-5(PC);				\
	/* set up argument registers */		\
	MOVV	regArgs+40(FP), R25;		\
	JAL	·unspillArgs(SB);		\
	/* call function */			\

	/* copy arguments to stack */		\
	MOVW	stackArgs+8(FP), R1;	\
	MOVW	stackArgsSize+12(FP), R2;	\
	MOVW	R29, R3;	\
	ADDU	$4, R3;	\
	ADDU	R3, R2;	\
	BEQ	R3, R2, 6(PC);	\
	MOVBU	(R1), R4;	\
	ADDU	$1, R1;	\
	MOVBU	R4, (R3);	\
	ADDU	$1, R3;	\
	JMP	-5(PC);	\
	/* call function */			\
	MOVW	f+4(FP), REGCTXT;	\
	MOVW	(REGCTXT), R4;	\
	PCDATA	$PCDATA_StackMapIndex, $0;	\
	JAL	(R4);	\