try {
            connection.dispatch(command);
            Result result = (Result) connection.receive();
            if (result instanceof Failure) {
                failure = ((Failure) result).getValue();
            }
            connection.dispatch(new Finished());
        } catch (Throwable e) {
            failure = e;
        }
        if (failure != null) {

		if value := http.MirrorPercent.GetValue(); value > 100 {
			errs = AppendValidation(errs, fmt.Errorf("mirror_percent must have a max value of 100 (it has %d)", value))
		}
		errs = AppendValidation(errs, WrapWarning(errors.New(`using deprecated setting "mirrorPercent", use "mirrorPercentage" instead`)))
	}

	if http.MirrorPercentage != nil {
		value := http.MirrorPercentage.GetValue()
		if value > 100 {

        try {
            Manifest manifest = findManifest(classpathFile);
            if (manifest == null) {
                return EMPTY;
            }
            String classpathEntry = manifest.getMainAttributes().getValue("Class-Path");
            if (classpathEntry == null || classpathEntry.trim().length() == 0) {
                return EMPTY;
            }
            return classpathEntry.split(" ");
        } catch (IOException e) {

  auto attr = composite_attrs.get(attr_name);
  if (!attr) return std::nullopt;
  if (auto bool_attr = mlir::dyn_cast_or_null<BoolAttr>(attr)) {
    return bool_attr.getValue();
  }
  return std::nullopt;
}

ShapedType GetNhwcReturnTypeFromNchw(Operation* old_op) {
  auto composite_result_shape =
      mlir::cast<ShapedType>(old_op->getResults().front().getType()).getShape();

        }
    }

    private static File gradleUserHome(ParsedCommandLine options) {
        if (options.hasOption(GRADLE_USER_HOME_OPTION)) {
            return new File(options.option(GRADLE_USER_HOME_OPTION).getValue());
        }
        return GradleUserHomeLookup.gradleUserHome();
    }

    private static Logger logger(ParsedCommandLine options) {
        return new Logger(options.hasOption(GRADLE_QUIET_OPTION));
    }

}


class SchemaTypeRefContext(val schema: AnalysisSchema) : TypeRefContext {
    override fun resolveRef(dataTypeRef: DataTypeRef): DataType = when (dataTypeRef) {
        is DataTypeRef.Name -> schema.dataClassesByFqName.getValue(dataTypeRef.fqName)
        is DataTypeRef.Type -> dataTypeRef.dataType
    }
}


/**
 * Represents a unique operation within a particular generation.  The invocation id should be unique within a single

            @Override
            String getJavaExpression() {
                return "(String)System.getProperties().entrySet().stream().filter(e -> e.getKey().equals(\"$name\")).findFirst().get().getValue()";
            }

            @Override
            String getGroovyExpression() {
                return "System.properties.entrySet().find { it.key == '$name'}.value"
            }

        List<Map.Entry<String, Set<String>>> attributesDistinctlyIdentifyingCandidates = unrequestedAttributesWithValues.entrySet().stream()
            .filter(entry -> entry.getValue().size() == failure.getCandidates().size())
            .collect(Collectors.toList());

        if (attributesDistinctlyIdentifyingCandidates.size() == 1) {

        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {
            return 1;
          }
        };

    builder.put(entry);
    holder.string = "two";
    assertEquals(Arrays.asList(1), builder.build().get("one"));
  }

        return requests.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .map(e -> toPropertyEntry(e.getValue()))
            .collect(Collectors.toList());
    }

    @SuppressWarnings("OptionalGetWithoutIsPresent")
    private static UpgradedProperty toPropertyEntry(List<CallInterceptionRequest> requests) {