*/
  private static final Collector<Object, ?, Optional<Object>> TO_OPTIONAL =
      Collector.of(
          () -> new ToOptionalState<>(null),
          ToOptionalState::add,
          ToOptionalState::combine,
          ToOptionalState::getOptional,
          Collector.Characteristics.UNORDERED);

  /**
   * A collector that converts a stream of zero or one elements to an {@code Optional}.
   *

      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ byteTable[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

#!/usr/bin/env bash

set -e
set -x

coverage combine
coverage report

7. Aquí el `response_model` está usando una anotación de tipo de una lista de dataclasses `Author`.

    Nuevamente, puedes combinar `dataclasses` con anotaciones de tipos estándar.

8. Nota que esta *path operation function* usa `def` regular en lugar de `async def`.

    Como siempre, en FastAPI puedes combinar `def` y `async def` según sea necesario.

7. Aqui o `response_model` está usando uma anotação de tipo de uma lista de dataclasses `Author`.

    Novamente, você pode combinar `dataclasses` com anotações de tipo padrão.

8. Note que esta *função de operação de rota* usa `def` regular em vez de `async def`.

    Como sempre, no FastAPI você pode combinar `def` e `async def` conforme necessário.

    }

    /**
     * Fixes unsupported combine.children attribute values.
     * Maven 4 only supports 'append' and 'merge', not 'override'.
     */
    private boolean fixUnsupportedCombineChildrenAttributes(Document pomDocument, UpgradeContext context) {
        boolean fixed = false;
        Element root = pomDocument.root();

        // Find all elements with combine.children="override" and change to "merge"

          // There is no contract one way or another as long as isSubtypeOf() works as expected.
          combined.addAll(asList(typeParam.getBounds()));
          if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
            combined.remove(Object.class);
          }
          return super.captureAsTypeVariable(combined.toArray(new Type[0]));
        }
      };
    }

        A accum = collector.supplier().get();
        for (T input : inputs) {
          A newAccum = collector.supplier().get();
          collector.accumulator().accept(newAccum, input);
          accum = collector.combiner().apply(accum, newAccum);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators right-to-left. */
    MERGE_RIGHT_ASSOCIATIVE {
      @Override

    Throwable cause = e.getCause();
    if (cause == null) {
      throw e;
    }
    if (combineStackTraces) {
      StackTraceElement[] combined =
          ObjectArrays.concat(cause.getStackTrace(), e.getStackTrace(), StackTraceElement.class);
      cause.setStackTrace(combined);
    }
    if (cause instanceof Exception) {
      throw (Exception) cause;
    }
    if (cause instanceof Error) {

INSTANTIATE_TEST_SUITE_P(
    UnifiedCAPI, CppGradients,
    ::testing::Combine(::testing::Values("graphdef", "mlir"),
                       /*tfrt*/ ::testing::Values(false),
                       /*executing_eagerly*/ ::testing::Values(true, false)));
#else
INSTANTIATE_TEST_SUITE_P(
    UnifiedCAPI, CppGradients,
    ::testing::Combine(::testing::Values("graphdef", "mlir"),