#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"
#include "tensorflow/c/experimental/ops/array_ops.h"
#include "tensorflow/c/experimental/ops/math_ops.h"
#include "tensorflow/c/experimental/ops/nn_ops.h"
#include "tensorflow/core/lib/llvm_rtti/llvm_rtti.h"
#include "tensorflow/core/platform/errors.h"

using std::vector;
using tensorflow::ops::BiasAddGrad;
using tensorflow::ops::ReluGrad;

namespace tensorflow {

 * @see CacheBuilder#withCleanupStrategy(CacheCleanupStrategy)
 */
public interface CleanupAction {

    void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor);

    CleanupAction NO_OP = new CleanupAction() {
        @Override
        public void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor) {
            // no-op
        }
    };

        }
        if (subscriptions.isRequested(OperationType.GENERIC)) {
            return new ClientForwardingBuildOperationListener(progressEventConsumer);
        }
        return NO_OP;
    }

    @Nonnull
    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {

import org.gradle.internal.state.ModelObject;

import javax.annotation.Nullable;

@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface PropertyHost {
    PropertyHost NO_OP = producer -> null;

    /**
     * Returns null if the host allows reads of its state, or a string that explains why reads are not allowed.
     */
    @Nullable
    String beforeRead(@Nullable ModelObject producer);

 */
public interface CacheCleanupStrategy {
    CacheCleanupStrategy NO_CLEANUP = new CacheCleanupStrategy() {
        @Override
        public CleanupAction getCleanupAction() {
            return CleanupAction.NO_OP;
        }

        @Override
        public CleanupFrequency getCleanupFrequency() {
            return CleanupFrequency.NEVER;
        }
    };

    /**
     * Returns the action to perform on cleanup.

import javax.inject.Inject;
import java.util.List;

import static org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionApplicator.NO_OP;

/**
 * Resolves a dependency graph and visits it. Essentially, this class is a {@link DependencyGraphBuilder} executor.
 */
public class DependencyGraphResolver {

 */

package org.gradle.api.internal.artifacts.dsl;

import org.gradle.api.artifacts.ModuleIdentifier;

import javax.annotation.Nullable;

public interface ModuleReplacementsData {
    ModuleReplacementsData NO_OP = new ModuleReplacementsData() {
        @Nullable
        @Override
        public Replacement getReplacementFor(ModuleIdentifier sourceModule) {
            return null;
        }

        @Override

@ServiceScope(Scope.BuildTree.class)
public interface VcsMappingsStore {
    VcsResolver asResolver();

    void addRule(Action<? super VcsMapping> rule, Gradle gradle);

    VcsResolver NO_OP = new VcsResolver() {
        @Nullable
        @Override
        public VersionControlSpec locateVcsFor(ModuleComponentSelector selector) {
            return null;
        }

        @Override

package org.gradle.internal.problems.failure;

/**
 * Listener for steps in the process of printing a failure by {@link FailurePrinter}.
 */
public interface FailurePrinterListener {

    FailurePrinterListener NO_OP = new FailurePrinterListener() {
        @Override
        public void beforeFrames() {}

        @Override
        public void beforeFrame(StackTraceElement element, StackTraceRelevance relevance) {}

	}
	tf := pass.Fset.AddFile(filename, -1, len(content))
	tf.SetLinesForContent(content)
	return content, tf, nil
}

// LineStart returns the position of the start of the specified line
// within file f, or NoPos if there is no line of that number.
func LineStart(f *token.File, line int) token.Pos {
	// Use binary search to find the start offset of this line.
	//
	// TODO(adonovan): eventually replace this function with the