*            The type of the second value
 * @param <T3>
 *            The type of the third value
 * @param <T4>
 *            The type of the fourth value
 */
public class Tuple4<T1, T2, T3, T4> {

    /** The first value */
    protected T1 value1;

    /** The second value */
    protected T2 value2;

    /** The third value */
    protected T3 value3;

    /** The fourth value */

     *            The fourth value
     * @param value5
     *            The fifth value
     * @return A tuple of five values
     */
    public static <T1, T2, T3, T4, T5> Tuple5<T1, T2, T3, T4, T5> tuple5(final T1 value1, final T2 value2, final T3 value3, final T4 value4,
            final T5 value5) {
        return new Tuple5<>(value1, value2, value3, value4, value5);
    }

    /**
     * Constructs an instance.

        final Method m3 = MapType.class.getMethod("mapOfWildcard");
        final Type t3 = m3.getGenericReturnType();
        assertThat(GenericsUtil.isTypeOf(t3, Map.class), is(true));
        assertThat(WildcardType.class.isInstance(GenericsUtil.getKeyTypeOfMap(t3)), is(true));
        assertThat(WildcardType.class.isInstance(GenericsUtil.getValueTypeOfMap(t3)), is(true));
    }

    /**
     * @throws Exception
     */

 * @param <T2>
 *            The type of the second value
 * @param <T3>
 *            The type of the third value
 */
public class Tuple3<T1, T2, T3> {

    /** The first value */
    protected T1 value1;

    /** The second value */
    protected T2 value2;

    /** The third value */
    protected T3 value3;

    /**
     * Creates and returns a tuple of three values.
     *

)

func TestLoadOrStoreVisitMap(t *testing.T) {
	var vm visitMap
	var loaded bool
	type testM struct {
		Name string
	}

	t1 := testM{Name: "t1"}
	t2 := testM{Name: "t2"}
	t3 := testM{Name: "t3"}

	vm = make(visitMap)
	if loaded = loadOrStoreVisitMap(&vm, reflect.ValueOf(&t1)); loaded {
		t.Fatalf("loaded should be false")
	}

	if loaded = loadOrStoreVisitMap(&vm, reflect.ValueOf(&t1)); !loaded {

    val t2 = System.nanoTime() / 1e6 - t1
    assertThat(t2).isCloseTo(750.0, 250.0)

    assertThat(log.take()).isEqualTo("runOnce delays.size=1")
    val t3 = System.nanoTime() / 1e6 - t1
    assertThat(t3).isCloseTo(1750.0, 250.0)
  }

  @Test fun taskFailsWithUncheckedException() {
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(100)) {
      log.put("failing task running")

y3) // X3 := t1 - Y3 y3.Add(t1, y3) // Y3 := t1 + Y3 y3.Mul(x3, y3) // Y3 := X3 * Y3 x3.Mul(x3, t3) // X3 := X3 * t3 t3.Add(t2, t2) // t3 := t2 + t2 t2.Add(t2, t3) // t2 := t2 + t3 z3.Mul({{.p}}B(), z3) // Z3 := b * Z3 z3.Sub(z3, t2) // Z3 := Z3 - t2 z3.Sub(z3, t0) // Z3 := Z3 - t0 t3.Add(z3, z3) // t3 := Z3 + Z3 z3.Add(z3, t3) // Z3 := Z3 + t3 t3.Add(t0, t0) // t3 := t0 + t0 t0.Add(t3, t0) // t0 := t3 + t0 t0.Sub(t0, t2) // t0 := t0 - t2 t0.Mul(t0, z3) // t0 := t0 * Z3 y3.Add(y3, t0) // Y3 := Y3...

		lines(
			"#define X() foo ",
			"X()",
			"X",
		),
		"foo.\n.X.\n",
	},
	{
		"multiline macro without arguments",
		lines(
			"#define A 1\\",
			"\t2\\",
			"\t3",
			"before",
			"A",
			"after",
		),
		"before.\n.1.\n.2.\n.3.\n.after.\n",
	},
	{
		"multiline macro with arguments",
		lines(
			"#define A(a, b, c) a\\",
			"\tb\\",
			"\tc",
			"before",

    assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class);
  }

  public <T> void testGetSubtype_manyGenericArgs() {
    class FourTypeArgs<T1, T2, T3, T4> {}
    class ThreeTypeArgs<T1, T2, T3> extends FourTypeArgs<T1, T2, T3, String> {}
    TypeToken<FourTypeArgs<T, Integer, ?, ?>> supertype =
        new TypeToken<FourTypeArgs<T, Integer, ?, ?>>() {};
    TypeToken<ThreeTypeArgs<T, Integer, String>> subtype =

	register["S6"] = riscv.REG_S6
	register["S7"] = riscv.REG_S7
	register["S8"] = riscv.REG_S8
	register["S9"] = riscv.REG_S9
	register["S10"] = riscv.REG_S10
	// Skip S11 as it is the g register.
	register["T3"] = riscv.REG_T3
	register["T4"] = riscv.REG_T4
	register["T5"] = riscv.REG_T5
	register["T6"] = riscv.REG_T6

	// Go runtime register names.
	register["g"] = riscv.REG_G
	register["CTXT"] = riscv.REG_CTXT