bool IsCastOpLegal(TF::CastOp cast_op) {
  // Consider qint <-> qint casts illegal.
  if (IsIllegalType(cast_op.getSrcT()) && IsIllegalType(cast_op.getDstT())) {
    return false;
  }
  // Consider CastOp illegal if either of its Src/Dst type is qint and is
  // connected to a non-UQ op.
  if (IsIllegalType(cast_op.getSrcT()) &&
      !(cast_op.getX().getDefiningOp() &&
        IsTFUniformQuantizedOp(cast_op.getX().getDefiningOp()))) {

      TF::CastOp op, TF::CastOpAdaptor adaptor,
      ConversionPatternRewriter &rewriter) const override {
    Type output_type = op.getDstT();
    if (!IsTFQintType(output_type) && !IsTFQintType(op.getSrcT())) {
      // skip CastOps with no qint types.
      return failure();
    }
    Value input = adaptor.getX();
    rewriter.replaceOpWithNewOp<mhlo::ConvertOp>(

        // Consider cast compatibility in case
        //    %cast = "tf.Cast"(%0) : (tensor<2xi64>) -> tensor<2xf32>
        // is skipped.
        if (cast_op.getSrcT() != cast_op.getDstT()) {
          break;
        }
        value = cast_op.getOperand();
      }
      return value;
    };
    Value first_arg = get_defining_op(std::get<0>(it));

            return nativePrefix;
        }

        private String resolveNativePrefix() {
            String arch = getArch();
            String osPrefix = getOsPrefix();
            osPrefix += "-" + arch;
            return osPrefix;
        }

        protected String getArch() {
            String arch = System.getProperty("os.arch");
            if ("x86".equals(arch)) {
                arch = "i386";

        }
        if (active && os.getName() != null) {
            active = determineNameMatch(os.getName(), actualOsName);
        }
        if (active && os.getArch() != null) {
            active = determineArchMatch(os.getArch(), actualOsArch);
        }
        if (active && os.getVersion() != null) {
            active = determineVersionMatch(os.getVersion(), actualOsVersion);
        }

        }
        if (active && os.getName() != null) {
            active = determineNameMatch(os.getName(), actualOsName);
        }
        if (active && os.getArch() != null) {
            active = determineArchMatch(os.getArch(), actualOsArch);
        }
        if (active && os.getVersion() != null) {
            active = determineVersionMatch(os.getVersion(), actualOsVersion);
        }

                p.getActivation().getProperty().getValue(),
                clone.getActivation().getProperty().getValue());
        assertEquals(
                p.getActivation().getOs().getArch(),
                clone.getActivation().getOs().getArch());
        assertEquals(
                p.getActivation().getOs().getFamily(),
                clone.getActivation().getOs().getFamily());
        assertEquals(

	type key struct {
		line    profile.Line
		inlined bool
	}
	srcs := map[key]int{} // Sources identified so far.
	seenFunctions := map[string]bool{}
	unknownIndex := 1
	getSrc := func(line profile.Line, inlined bool) int {
		k := key{line, inlined}
		if i, ok := srcs[k]; ok {
			return i
		}
		x := StackSource{Places: []StackSlot{}} // Ensure Places is non-nil

            org.apache.maven.api.model.ActivationOS modelOs = modelActivation.getOs();

            if (modelOs != null) {
                ActivationOS os = ActivationOS.newBuilder()
                        .arch(modelOs.getArch())
                        .family(modelOs.getFamily())
                        .name(modelOs.getName())
                        .version(modelOs.getVersion())
                        .build();

    }

    static boolean canUseReadelf() {
        def process = ['readelf', '-v'].execute()
        return process.waitFor() && process.exitValue() == 0
    }

    ArchitectureInternal getArch() {
        def process = ['readelf', '-h', binaryFile.absolutePath].execute()
        List<String> lines = process.inputStream.readLines()
        return readArch(lines)
    }

    List<String> listObjectFiles() {