fmt.Fprintf(os.Stdout, format+"\n", args...)
			}
		}
	}

	switch v := entry.(type) {
	case log.Entry:
		if v.Trace == nil {
			logf("%s: %s", v.Level, v.Message)
		} else {
			msg := fmt.Sprintf("%s: %+v", v.Level, v.Trace.Message)
			for i, m := range v.Trace.Source {
				if i == 0 && strings.Contains(m, "logger.go:") {
					continue
				}
				msg += fmt.Sprintf("\n%s", m)
			}

	}

	kvs := jstream.KVS{}
	for _, col := range pr.r.Columns() {

		var value interface{}
		if v, ok := nextRow[col.FlatName()]; ok {
			value, err = convertFromAnnotation(col.Element(), v)
			if err != nil {
				return nil, errParquetParsingError(err)
			}
		}
		kvs = append(kvs, jstream.KV{Key: col.FlatName(), Value: value})
	}

	// Reuse destination if we can.

  </description>
  <classes>
    <class rootElement="true" xml.tagName="lifecycles" xsd.compositor="sequence">
      <name>LifecycleConfiguration</name>
      <version>1.0.0+</version>
      <description>Root element of the {@code lifecycle.xml} file.</description>
      <fields>
        <field>
          <name>lifecycles</name>
          <version>1.0.0+</version>
          <association xml.itemsStyle="flat">

  public void testRemove_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> collection.remove(e0()));
    expectUnchanged();
    assertTrue("remove(present) should not remove the element", collection.contains(e0()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertFalse(

    doTestSet(e3());
  }

  private void doTestSet(E newValue) {
    int index = aValidIndex();
    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));

   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  Iterable<? extends N> predecessors(N node);

    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
    permissions:
      # required for all workflows
      security-events: write

      # required to fetch internal or private CodeQL packs
      packages: read

      # only required for workflows in private repositories
      actions: read
      contents: read

    strategy:

   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  Iterable<? extends N> successors(N node);

     */
    protected abstract List<Byte> create(Byte[] elements);

    @Override
    public Byte[] createArray(int length) {
      return new Byte[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Byte> order(List<Byte> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleBytes extends SampleElements<Byte> {

     */
    protected abstract List<Long> create(Long[] elements);

    @Override
    public Long[] createArray(int length) {
      return new Long[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Long> order(List<Long> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleLongs extends SampleElements<Long> {