val |= int(v & 0x7F)

		if v&0x80 == 0 {
			if len(out) == 0 {
				if val < 80 {
					out = append(out, val/40)
					out = append(out, val%40)
				} else {
					out = append(out, 2)
					out = append(out, val-80)
				}
				val = 0
				continue
			}
			out = append(out, val)
			val = 0
		}
	}

	return out, true

            configurationCache.assertStateStored()
            testDirectory.file("build/out.txt").text == "yes"
        } else {
            // This is incorrect behavior of configuration cache that is a result of using the opt-out flag
            configurationCache.assertStateLoaded()
            testDirectory.file("build/out.txt").text == "no"
        }

        where:
        isOptOut | _
        true     | _

    protected final MessageBuilderFactory messageBuilderFactory;
    protected final PrintStream out;

    protected AbstractMavenTransferListener(MessageBuilderFactory messageBuilderFactory, PrintStream out) {
        this.messageBuilderFactory = messageBuilderFactory;
        this.out = out;
    }

    @Override
    public void transferInitiated(TransferEvent event) {

    private final boolean printResourceNames;
    private int lastLength;

    public ConsoleMavenTransferListener(
            MessageBuilderFactory messageBuilderFactory, PrintStream out, boolean printResourceNames) {
        super(messageBuilderFactory, out);
        this.printResourceNames = printResourceNames;
    }

    @Override
    public void transferInitiated(TransferEvent event) {
        overridePreviousTransfer(event);

        System.out.println("ACTION STARTED");
        GradleProject gradleProject = controller.getModel(GradleProject.class);
        controller.send(gradleProject);

        System.out.println("ACTION WAITING");
        try {
            uri.toURL().openConnection().getContentLength();
        } catch (IOException e) {
            e.printStackTrace(System.out);
            throw new RuntimeException(e);

	localEnvoyFilter := local.Spec.(*networking.EnvoyFilter)

	out := &EnvoyFilterWrapper{Name: local.Name, Namespace: local.Namespace, Priority: localEnvoyFilter.Priority, creationTime: local.CreationTimestamp}
	if localEnvoyFilter.WorkloadSelector != nil {
		out.workloadSelector = localEnvoyFilter.WorkloadSelector.Labels
	}
	out.Patches = make(map[networking.EnvoyFilter_ApplyTo][]*EnvoyFilterConfigPatchWrapper)

            launcherSpec()
            launcher.setStandardOutput(out)
            launcher.run()
        }
    }

    private boolean hasNoSystemProperty(String key, String value = null) {
        !out.toString().contains("$key=${value ?: ""}")
    }

    private boolean hasSystemProperty(String key, String value) {
        out.toString().contains("$key=$value")
    }

func (e *Environment) IsMultiNetwork() bool {
	return len(e.ClustersByNetwork()) > 1
}

func (e *Environment) AllClusters() cluster.Clusters {
	out := make([]cluster.Cluster, 0, len(e.clusters))
	out = append(out, e.clusters...)
	return out
}

func (e *Environment) Clusters() cluster.Clusters {
	return e.AllClusters().MeshClusters()
}

    /**
     * [onModification] is invoked in a write action before or after an out-of-block modification happens in [module]'s source code.
     *
     * See [KotlinModificationTrackerFactory.createProjectWideOutOfBlockModificationTracker] for an explanation of out-of-block
     * modifications.
     *
     * This event may be published for any and all source code changes, not just out-of-block modifications, to simplify the implementation

		hostsByNamespace[ns] = hc
	}

	out.virtualServices = SelectVirtualServices(ps.virtualServiceIndex, configNamespace, hostsByNamespace)
	svces := ps.servicesExportedToNamespace(configNamespace)
	out.services = out.selectServices(svces, configNamespace, hostsByNamespace)
	out.mostSpecificWildcardVsIndex = computeWildcardHostVirtualServiceIndex(out.virtualServices, out.services)

	return out
}