html_url: https://github.com/uriyyo/fastapi-pagination
  stars: 1638
  owner_login: uriyyo
  owner_html_url: https://github.com/uriyyo
- name: bracket
  html_url: https://github.com/evroon/bracket
  stars: 1638
  owner_login: evroon
  owner_html_url: https://github.com/evroon
- name: langchain-serve
  html_url: https://github.com/jina-ai/langchain-serve
  stars: 1634
  owner_login: jina-ai

  
  kubeadm: started using k8s.io/system-validators v1.12.1 in kubeadm 1.35. During `kubeadm init`, `kubeadm join` and `kubeadm upgrade`, the SystemVerification preflight check will throw an error if cgroups v1 is detected and if the detected kubelet version is 1.35 or newer. For older versions of kubelet, there will be just a preflight warning.
  

    assertThat(fluent(1, 3, 5).copyInto(Lists.newArrayList(1, 2)))
        .containsExactly(1, 2, 1, 3, 5)
        .inOrder();
  }

  public void testCopyInto_set() {
    assertThat(fluent(1, 3, 5).copyInto(newHashSet(1, 2))).containsExactly(1, 2, 3, 5);
  }

  public void testCopyInto_setAllDuplicates() {
    assertThat(fluent(1, 3, 5).copyInto(newHashSet(1, 2, 3, 5))).containsExactly(1, 2, 3, 5);
  }

map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}

type PPoint *Point
[2]*Point{{1.5, -3.5}, {}}          // same as [2]*Point{&Point{1.5, -3.5}, &Point{}}
[2]PPoint{{1.5, -3.5}, {}}          // same as [2]PPoint{PPoint(&Point{1.5, -3.5}), PPoint(&Point{})}
</pre>

<p>
Examples of valid array, slice, and map literals:
</p>

<pre>

    ticker.advance(8998);
    assertThat(stopwatch.toString()).isEqualTo("9.999 \u03bcs");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(1234567);
    assertThat(stopwatch.toString()).isEqualTo("1.235 ms");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(5000000000L);
    assertThat(stopwatch.toString()).isEqualTo("5.000 s");
    stopwatch.reset();
    stopwatch.start();

// Its value is the maximum value of the int64 type, which means that when the cache size is not specified,
// the cache can theoretically store as many elements as possible.
// (1 << 63) - 1 is the maximum value that an int64 type can represent.
const (
	defaultMaxSize = math.MaxInt
	// defaultTTL defines the default time-to-live (TTL) for each cache entry.

    testRotate(new long[] {1, 2}, 1, new long[] {2, 1});
    testRotate(new long[] {1, 2}, 2, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 3, new long[] {2, 1});

    testRotate(new long[] {1, 2, 3}, -5, new long[] {3, 1, 2});
    testRotate(new long[] {1, 2, 3}, -4, new long[] {2, 3, 1});
    testRotate(new long[] {1, 2, 3}, -3, new long[] {1, 2, 3});
    testRotate(new long[] {1, 2, 3}, -2, new long[] {3, 1, 2});

  // Integer.valueOf(int), and some that are not cached. (127 is the highest cached value.)
  static final int WARMUP_MIN = 120;
  static final int WARMUP_MAX = 135;
  static final int WARMUP_SIZE = WARMUP_MAX - WARMUP_MIN;

  public void testSize_populated() {
    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed

        Ordering.<Integer>natural().nullsLast().leastOf(list, list.size() - 1);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.of(-1, 3, 5), result);
  }

  public void testLeastOfIterator_simple_nMinusOne_withNullElement() {
    Iterator<@Nullable Integer> itr = Iterators.forArray(3, null, 5, -1);

        Ordering.<Integer>natural().nullsLast().leastOf(list, list.size() - 1);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.of(-1, 3, 5), result);
  }

  public void testLeastOfIterator_simple_nMinusOne_withNullElement() {
    Iterator<@Nullable Integer> itr = Iterators.forArray(3, null, 5, -1);