class ContributorsResults(BaseModel):
    contributors: Counter[str]
    translation_reviewers: Counter[str]
    translators: Counter[str]
    authors: dict[str, Author]


def get_contributors(pr_nodes: list[PullRequestNode]) -> ContributorsResults:
    contributors = Counter[str]()
    translation_reviewers = Counter[str]()
    translators = Counter[str]()
    authors: dict[str, Author] = {}

      void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override
      void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
        long[] array = new long[random.nextInt(10)];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();
        }
        builder.addAll(array);

  public void testSingleSimpleStats() {
    StatsCounter counter = new SimpleStatsCounter();
    for (int i = 0; i < 11; i++) {
      counter.recordHits(1);
    }
    for (int i = 0; i < 13; i++) {
      counter.recordLoadSuccess(i);
    }
    for (int i = 0; i < 17; i++) {
      counter.recordLoadException(i);
    }
    for (int i = 0; i < 23; i++) {
      counter.recordMisses(1);
    }

public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {
    private final Deque<E> delegate = new LinkedList<>();

     */
    static class InnerClass {
        InnerEnum enumProp

        /**
         * This is an inner inner class.
         */
        class AnotherInner {
            InnerClass outer
        }
    }

    GroovyInterface getSomeProp() {
        // ignore anonymous classes
        return new GroovyInterface() {}
    }

    InnerClass.AnotherInner innerClassProp

app = FastAPI()

counter_holder = {"counter": 0}


async def dep_counter():
    counter_holder["counter"] += 1
    return counter_holder["counter"]


async def super_dep(count: int = Depends(dep_counter)):
    return count


@app.get("/counter/")
async def get_counter(count: int = Depends(dep_counter)):
    return {"counter": count}


@app.get("/sub-counter/")
async def get_sub_counter(

   * c, d, e]} with a partition size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list
   * containing two inner lists of three and two elements, all in the original order.
   *
   * <p>The outer list is unmodifiable, but reflects the latest state of the source list. The inner

public class SynchronizedQueueTest extends TestCase {

  protected Queue<String> create() {
    TestQueue<String> inner = new TestQueue<>();
    Queue<String> outer = Synchronized.queue(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestQueue<E> implements Queue<E> {
    private final Queue<E> delegate = new LinkedList<>();

      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        double[] array = new double[random.nextInt(10)];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();
        }

	for mv = range decoder.Stream() {
		if mv.Value != expected[counter].Value {
			t.Fatalf("got %v, expected: %v", mv.Value, expected[counter])
		}
		if mv.ValueType != expected[counter].ValueType {
			t.Fatalf("got %v value type, expected: %v value type", mv.ValueType, expected[counter].ValueType)
		}
		counter++
		t.Logf("depth=%d offset=%d len=%d (%v)", mv.Depth, mv.Offset, mv.Length, mv.Value)
	}