}
				mem = bEnd.NewValue3I(pos, OpMove, types.TypeMem, w.AuxInt, dst, src, mem)
				mem.Aux = w.Aux
			case OpVarDef, OpVarLive:
				mem = bEnd.NewValue1A(pos, w.Op, types.TypeMem, w.Aux, mem)
			case OpStore:
				ptr := w.Args[0]
				val := w.Args[1]
				mem = bEnd.NewValue3A(pos, OpStore, types.TypeMem, w.Aux, ptr, val, mem)
			}
		}

    }

    /**
     * 指定されたキーと値を持つ{@link TreeMap}を構築するための{@literal Maps}を返します。
     *
     * @param <KEY>
     *            <code>Map</code>のキーの型
     * @param <VALUE>
     *            <code>Map</code>の値ーの型
     * @param key
     *            <code>Map</code>に追加されるキー
     * @param value
     *            <code>Map</code>に追加される値
     * @return 指定されたキーと値を持つ{@link TreeMap}を構築するための{@literal Maps}
     */

import java.util.Collection;
import java.util.Map;
import java.util.TreeMap;

/**
 * The test results for a given package.
 */
public class PackageTestResults extends CompositeTestResults {
    private static final String DEFAULT_PACKAGE = "default-package";
    private final String name;
    private final Map<String, ClassTestResults> classes = new TreeMap<String, ClassTestResults>();

package ssa

import (
	"cmd/compile/internal/types"
	"strings"
	"testing"
)

func TestSCCPBasic(t *testing.T) {
	c := testConfig(t)
	fun := c.Fun("b1",
		Bloc("b1",
			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
			Valu("v1", OpConst64, c.config.Types.Int64, 20, nil),
			Valu("v2", OpConst64, c.config.Types.Int64, 21, nil),
			Valu("v3", OpConst64F, c.config.Types.Float64, 21.0, nil),

        return new InstrumentationArtifactMetadata(artifact.getName(), hash);
    }

    private static Map<String, Set<String>> toMapWithKeys(Set<String> keys) {
        TreeMap<String, Set<String>> map = new TreeMap<>();
        keys.forEach(key -> map.put(key, Collections.emptySet()));
        return map;
    }

import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;
import java.util.Comparator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;

/**
 * Joins a primary and fallback attribute container to each other. Any attribute in the primary
 * container will override attributes in the fallback container. All mutation operations are

	"istio.io/istio/pkg/monitoring"
)

var (
	Log = istiolog.RegisterScope("ads", "ads debugging")
	log = Log

	errTag  = monitoring.CreateLabel("err")
	nodeTag = monitoring.CreateLabel("node")
	typeTag = monitoring.CreateLabel("type")

	TotalXDSInternalErrors = monitoring.NewSum(
		"pilot_total_xds_internal_errors",
		"Total number of internal XDS errors in pilot.",
	)

	ExpiredNonce = monitoring.NewSum(

import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;
import java.io.File;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import static org.gradle.api.internal.initialization.transform.utils.InstrumentationTransformUtils.DEPENDENCY_ANALYSIS_FILE_NAME;

import org.gradle.internal.hash.FileHasher;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicBoolean;

import static java.lang.String.format;

public class ZipFileTree extends AbstractArchiveFileTree {
    private static final String ZIP_ENTRY_PREFIX = "zip entry";

MODULE_FRAGMENT
  FILE fqName:<root> fileName:main.kt
    FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Unit
      BLOCK_BODY
        TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit