}
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = Lists.newArrayList();
    for (int i = 0; i < n; i++) {
      callables.add(Callables.returning(RESULT_VALUE + i));
    }
    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    }
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = Lists.newArrayList();
    for (int i = 0; i < n; i++) {
      callables.add(Callables.returning(RESULT_VALUE + i));
    }
    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

            directExecutor());
    for (int i = 0; i < 25_000; i++) {
      serializer.submit(Callables.<Void>returning(null), directExecutor()).cancel(true);
      unused = serializer.submit(Callables.<Void>returning(null), directExecutor());
    }
    ListenableFuture<Integer> stackDepthCheck =
        serializer.submit(
            new Callable<Integer>() {
              @Override
              public Integer call() {

            directExecutor());
    for (int i = 0; i < 25_000; i++) {
      serializer.submit(Callables.<Void>returning(null), directExecutor()).cancel(true);
      unused = serializer.submit(Callables.<Void>returning(null), directExecutor());
    }
    ListenableFuture<Integer> stackDepthCheck =
        serializer.submit(
            new Callable<Integer>() {
              @Override
              public Integer call() {

                    runnableThrowing(exception), DELAY_MS, TimeUnit.MILLISECONDS));
    assertThat(e.getCause()).isEqualTo(exception);
  }

  public static <T> Callable<T> callableThrowing(final Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

                    runnableThrowing(exception), DELAY_MS, TimeUnit.MILLISECONDS));
    assertThat(e.getCause()).isEqualTo(exception);
  }

  public static <T> Callable<T> callableThrowing(final Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

            baseScope.processAllCallables { callable ->
                if (isTargetCallable(callable)) {
                    add(callable.name)
                }
            }
        }
    }

    override fun getCallableNames(): Set<Name> = cachedCallableNames

    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
        if (!cachedCallableNames.contains(name)) return

    /**
     * Executes the given {@code callable} in the context of an entry point produced from entering a dynamically dispatched
     * call described by the {@code callableName} and {@code kind}
     * from a class identified by {@code consumerClass}.
     * After running the callable, ensures that the entry point leaves the context and returns the callable's result.
     */

            std::move(trace), input_signature, output_tensor_spec);
      }
      TaggedValue callable = MakeCallable(child_name, tf_function, ctx);
      module.dict()[TaggedValue(child_name)] = callable;
    }
  }
  return module;
}

// Instantiate the Runtime, creating relevant Callables for later use.
Runtime::Runtime(AbstractContext* ctx) {
  TaggedValue ctx_capsule =

    }

    /**
     * Calls the given callable converting any thrown exception to an unchecked exception via {@link UncheckedException#throwAsUncheckedException(Throwable)}
     *
     * @param callable The callable to call
     * @param <T> Callable's return type
     * @return The value returned by {@link Callable#call()}
     */
    @Nullable
    public static <T> T uncheckedCall(Callable<T> callable) {
        try {