func machoRewriteUuid(ctxt *Link, exef *os.File, exem *macho.File, outexe string) error {
	outf, err := os.OpenFile(outexe, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
	if err != nil {
		return err
	}
	defer outf.Close()

	// Copy over the file.
	if _, err := io.Copy(outf, exef); err != nil {
		return err
	}

	// Locate the portion of the binary containing the load commands.

	SUBVU	R9, R5, R7
	AND	$7, R7
	BNE	R7, out1

	// if less than 8 bytes, do byte copying
	SGTU	$8, R6, R7
	BNE	R7, out1

	// do one byte at a time until 8-aligned
	AND	$7, R9, R8
	BEQ	R8, words1
	ADDV	$-1, R5
	MOVB	(R5), R7
	ADDV	$-1, R9
	MOVB	R7, (R9)
	JMP	-6(PC)

words1:
	// do 8 bytes at a time if there is room
	ADDV	$7, R4, R6 // R6 is start pointer+7

  }];

  let description = [{
This op captures all needed live-in values.
  }];

  let arguments = (ins
    StrAttr:$device
  );

  let results = (outs
    Variadic<AnyType>:$results
  );

  let regions = (region SizedRegion<1>:$body);

  let extraClassDeclaration = [{
    Block &GetBody() { return getOperation()->getRegion(0).front(); }
    bool WrapsSingleOp();

  Flatten(value, &args);
  std::vector<AbstractTensorHandle*> outs(
      GetFlatSize(concrete_fn.output_signature));
  TF_RETURN_IF_ERROR(
      ExecuteFunction(concrete_fn.trace, ctx, args, absl::MakeSpan(outs)));
  auto cleanup_tensors = absl::MakeCleanup([outs]() {
    for (auto t : outs) {
      t->Unref();
    }
  });
  return Unflatten(outs, concrete_fn.output_signature);
}

)

[[
    genrule(
        name = "gen_" + config_file,
        testonly = 1,
        srcs = [template_file],
        outs = [config_file],
        cmd = ("sed " + sed_replace + " " +
               "$(location " + template_file + ") " +
               "> $(OUTS)"),
        tags = ["manual"],
    ),
    tf_library(
        name = bench_name,
        testonly = 1,
        config = config_file,

			mustRun(t, cmd)

			cmd = hangProneCmd(outPath)
			cmd.Dir = dir.Base()
			outb, err := cmd.CombinedOutput()
			out := string(outb)
			if err == nil {
				t.Fatalf("fuzzing succeeded unexpectedly; output:\n%s", out)
			}
			if !strings.Contains(out, tc.expectedError) {
				t.Errorf("exited without expected error %q; got\n%s", tc.expectedError, out)
			}
		})
	}
}

ret=$?
function cleanup() {
  rm -f "${OUTPUT}"
}

trap cleanup EXIT

if [[ ${ret} -eq 0 ]];then
  cat "${OUTPUT}"
else
  # ignore NotFound errors
  OUT2=$(grep -v NotFound "${OUTPUT}")
  if [[ -n ${OUT2} ]];then
    cat "${OUTPUT}"
    exit ${ret}
  fi
fi

# wait for 30 sec for bookinfo to clean up
sleep 30

        srcs_version = "PY3",
        python_version = "PY3",
        deps = py_deps,
    )

    registered_op = "registered_" + name
    native.genrule(
        name = registered_op,
        srcs = [],
        outs = [name + ".inc.cc"],
        cmd = "$(location %s) --output=$@ --gen_register_op=true" % gen_op_lib_exec,
        tools = [":" + gen_op_lib_exec],
        tags = tags,
    )

    native.cc_library(

			}
		}
	}

	outb, err = vcsBzr.runOutputVerboseOnly(rootDir, "status")
	if err != nil {
		return Status{}, err
	}

	// Skip warning when working directory is set to an older revision.
	if bytes.HasPrefix(outb, []byte("working tree is out of date")) {
		i := bytes.IndexByte(outb, '\n')
		if i < 0 {
			i = len(outb)
		}
		outb = outb[:i]
	}
	uncommitted := len(outb) > 0

    DefaultValuedOptionalAttr<I64Attr, "-128">:$output_quantization_min_val,
    DefaultValuedOptionalAttr<I64Attr, "127">:$output_quantization_max_val
  );

  let results = (outs
    TensorOf<[TF_Qint32]>:$output
  );

  TF_DerivedOperandTypeAttr LhsT = TF_DerivedOperandTypeAttr<0>;
  TF_DerivedOperandTypeAttr RhsT = TF_DerivedOperandTypeAttr<1>;