val stage2 = remainingSource
                .takeIf { it.text.isNotBlank() }
                ?.let(Program::Script)

            stage1?.let { s1 ->
                stage2?.let { s2 ->
                    Program.Staged(s1, s2)
                } ?: s1
            }
                ?: stage2
                ?: Program.Empty
        }
    }

    private
    fun rangesToErase(

        buildScript """
            class Rules extends RuleSource {
              @Model
              String s1(Integer iDontExist) {
                "foo"
              }
            }

            pluginManager.apply Rules
        """

        then:
        fails "help"
        failureCauseContains("""
  Rules#s1(Integer)
    inputs:
      - <no path> Integer (parameter 1) [*]

        WeaklyTypeReferencingMethod.of(declaringType, ModelType.of(method.returnType), method)
    }

    def noArgs() {}

    def oneArg(String s1) {}

    def twoArgs(String s1, String s2) {}

    def genericArgs(List<String> list, Map<Integer, List<String>> map) {}

    class Outer {
        static class Inner {
            def noArgs() {}
        }
    }

    private static class OptionComparator implements Comparator<Option> {
        public int compare(Option opt1, Option opt2) {
            String s1 = opt1.getOpt() != null ? opt1.getOpt() : opt1.getLongOpt();
            String s2 = opt2.getOpt() != null ? opt2.getOpt() : opt2.getLongOpt();
            return s1.compareToIgnoreCase(s2);
        }
    }

    private static class CLIManagerExtension extends CLIManager {

		// Compute the multiplication
		s0, s1 := bits.Mul64(prime128Lower, s[1])
		s0 += s[1]<<prime128Shift + prime128Lower*s[0]
		// Update the values
		s[1] = s1
		s[0] = s0
		s[1] ^= uint64(c)
	}
	return len(data), nil
}

func (s *sum128a) Write(data []byte) (int, error) {
	for _, c := range data {
		s[1] ^= uint64(c)
		// Compute the multiplication
		s0, s1 := bits.Mul64(prime128Lower, s[1])

	f.Add(string([]rune{unicode.ReplacementChar}))

	f.Fuzz(func(t *testing.T, s1 string) {
		b := marshalCorpusFile(s1)
		t.Logf("marshaled %q:\n%s", s1, b)

		rs, err := unmarshalCorpusFile(b)
		if err != nil {
			t.Fatal(err)
		}
		if len(rs) != 1 {
			t.Fatalf("unmarshaled %d values", len(rs))
		}
		s2 := rs[0].(string)
		if s2 != s1 {
			t.Errorf("unmarshaled %q", s2)
		}
	})

	sizes := []int64{1 << 3, 1 << 7, 1 << 11, 1 << 15}
	for _, size := range sizes {
		b.Run(fmt.Sprintf("%dBytes", size), func(b *testing.B) {
			s0 := data0[:size]
			s1 := data1[:size]
			b.SetBytes(int64(size))
			for i := 0; i < b.N; i++ {
				XORBytes(dst, s0, s1)
			}
		})
	}
}

func mustPanic(t *testing.T, expected string, f func()) {
	t.Helper()
	defer func() {
		switch msg := recover().(type) {
		case nil:

import org.apache.maven.model.Plugin;

/**
 */
class CacheUtils {

    /**
     * @deprecated Use {@link Objects#equals(Object)}
     */
    @Deprecated
    public static <T> boolean eq(T s1, T s2) {
        return Objects.equals(s1, s2);
    }

    /**
     * @deprecated Use {@link Objects#hashCode(Object)}
     */
    @Deprecated
    public static int hash(Object obj) {
        return obj != null ? obj.hashCode() : 0;

  protected void setUp() throws Exception {
    bus = new EventBus();
    methodCalled = false;
    methodArgument = null;
  }

  public void testCreate() {
    Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod"));
    assertThat(s1).isInstanceOf(Subscriber.SynchronizedSubscriber.class);

    // a thread-safe method should not create a synchronized subscriber

		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
	}
}

func main() {
	s1 := runServer(":8080", instAttrs)
	s2 := runServer(":8081", vmInstAttrs)
	done := make(chan os.Signal, 1)
	signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
	log.Println("GCE metadata server started")
	<-done
	if err := s1.Shutdown(context.Background()); err != nil {
		log.Fatalf("GCE Metadata Shutdown Failed: %+v", err)
	}