*/
@FunctionalInterface
public interface IoRunnable {
    void run() throws IOException;

    /**
     * Wraps an {@link IOException}-throwing {@link IoRunnable} into a regular {@link Runnable}.
     *
     * Any {@code IOException}s are rethrown as {@link UncheckedIOException}.
     */
    static Runnable wrap(IoRunnable runnable) {
        return () -> {
            try {
                runnable.run();

@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class CountingOutputStream extends FilterOutputStream {

  private long count;

  /**
   * Wraps another output stream, counting the number of bytes written.
   *
   * @param out the output stream to be wrapped
   */
  public CountingOutputStream(OutputStream out) {
    super(checkNotNull(out));
  }

  /** Returns the number of bytes written. */

				lastErr = errors.Wrapf(err, "failed to stop running pod %s", container)
				cancel()
				continue
			}
			cancel()

			ctx, cancel = defaultContext()
			if err := runtime.impl.RemovePodSandbox(ctx, runtime.runtimeService, container); err != nil {
				lastErr = errors.Wrapf(err, "failed to remove pod %s", container)
				cancel()
				continue
			}

 */

package org.gradle.api.internal;

import org.gradle.api.Action;
import org.gradle.api.InvalidUserCodeException;

/**
 * A delegating {@link Action} implementation that wraps exceptions in InvalidUserCodeException.
 * Used to wrap a closure or action parameter that contains user-provided executable code.
 * @param <T>
 */
public class UserCodeAction<T> implements Action<T> {
    private final String exceptionMessage;

// Internal structures used by the SavedModel C API. These are likely to change
// and should not be depended on.

// It doesn't make sense to wrap tensorflow::ConcreteFunction* in a separate
// struct, since the lifetime of the struct and the raw pointer it wraps would
// be different. Therefore TF_ConcreteFunction* = tensorflow::ConcreteFunction*.
typedef struct TF_ConcreteFunction TF_ConcreteFunction;

namespace tensorflow {

		}),
	}, nil
}

// SetAuthenticationInfoResolverWrapper sets the
// AuthenticationInfoResolverWrapper.
func (cm *ClientManager) SetAuthenticationInfoResolverWrapper(wrapper AuthenticationInfoResolverWrapper) {
	if wrapper != nil {
		cm.authInfoResolver = wrapper(cm.authInfoResolver)
	}
}

// SetAuthenticationInfoResolver sets the AuthenticationInfoResolver.

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops_a_m.h"

namespace mlir {
namespace TFL {

// Moves the TF operations out from the tfl.TFCustomOps wrappers inside the
// function. This is a no-op for the ops which are not wrapped.
LogicalResult UnwrapTFCustomOps(func::FuncOp fn, OpBuilder& builder) {
  llvm::SmallVector<Operation*, 4> wrapped_ops;
  fn.walk([&](TFL::CustomTfOp custom_op) {
    auto* real_op = &custom_op.getBody().front().front();

	}

	// Parse the files.
	users, err := parseEntries(fileUsers, totalFieldsUser)
	if err != nil {
		return nil, errors.Wrapf(err, "could not parse %q", pathUsers)
	}
	groups, err := parseEntries(fileGroups, totalFieldsGroup)
	if err != nil {
		return nil, errors.Wrapf(err, "could not parse %q", pathGroups)
	}

	klog.V(klogLevel).Info("Validating existing users and groups")

	case ir.OCALLFUNC:
		call := call.(*ir.CallExpr)

		// If the callee is a named function, link to the original callee.
		if wrapped := ir.StaticCalleeName(call.Fun); wrapped != nil {
			wrapperFn.WrappedFunc = wrapped.Func
		}

		visit(&call.Fun)
		visitList(call.Args)

	case ir.OCALLINTER:
		call := call.(*ir.CallExpr)

            // Even if the build operation of the delegate would be different, it would override a new wrapper anyway,
            // so we can just return the delegate.
            return delegate;
        }
        BuildOperationRef buildOperation = ref.get();
        if (buildOperation == null) {
            // No build operation, so no need to wrap.
            return delegate;
        }