for (Node* n : graph_->nodes()) {
    if (n->IsMerge()) {
      for (const Edge* e : n->in_edges()) {
        if (e->src()->IsNextIteration()) {
          back_edges_.push_back(
              BackEdge{e, e->src(), e->src_output(), e->dst(), e->dst_input()});
        }
      }
    }
  }
  for (const BackEdge& be : back_edges_) {
    graph_->RemoveEdge(be.edge);
  }
  return absl::OkStatus();
}

    return rewriter.create<TF::ConstOp>(loc, static_shape_attr).getOutput();
  }

  // If the shape is not static, create a new ShapeOp.
  BoolAttr false_attr = rewriter.getBoolAttr(false);
  return rewriter
      .create<TF::ShapeOp>(loc, input,
                           /*use_32bit=*/false_attr)
      .getOutput();
}

mlir::TFL::MirrorPaddingType GetTFLMirrorPaddingFromString(

        if (component instanceof SourceComponentSpec) {
            SourceComponentSpec sourceComponentSpec = (SourceComponentSpec) component;
            builder.getOutput().println();
            builder.collection("Source sets", CollectionUtils.sort(sourceComponentSpec.getSources().values(), SourceSetRenderer.SORT_ORDER), sourceSetRenderer, "source sets");
        }

	}
}

func TestSUID(t *testing.T) {
	// This test is relatively simple, we build a test program which opens a
	// file passed via the TEST_OUTPUT envvar, prints the value of the
	// GOTRACEBACK envvar to stdout, and prints "hello" to stderr. We then chown
	// the program to "nobody" and set u+s on it. We execute the program, only

        def resultHandler = new TestResultHandler()
        build.run(resultHandler)

        poll(60) {
            assert getOutput().contains(FOO.prompt)
        }

        stdinWriter.write((answer1 + System.getProperty('line.separator')).bytes)

        poll(60) {
            assert getOutput().contains(BAR.prompt)
        }

        stdinWriter.write((answer2 + System.getProperty('line.separator')).bytes)

// license that can be found in the LICENSE file.

package flag_test

import (
	"flag"
	"fmt"
	"net"
	"os"
)

func ExampleTextVar() {
	fs := flag.NewFlagSet("ExampleTextVar", flag.ContinueOnError)
	fs.SetOutput(os.Stdout)
	var ip net.IP
	fs.TextVar(&ip, "ip", net.IPv4(192, 168, 0, 100), "`IP address` to parse")
	fs.Parse([]string{"-ip", "127.0.0.1"})
	fmt.Printf("{ip: %v}\n\n", ip)

	// 256 is not a valid IPv4 component

      const Edge* edge = in_edges[i];
      data_inputs[i] = {edge->src(), edge->src_output()};
      arg_types[i] = EdgeType(edge);
    }

    // Appends the variable inputs.
    for (int i = 0; i < num_variables; ++i) {
      int pos = variable_start_index + i;
      const Edge* edge = in_edges[pos];
      data_inputs[pos] = {edge->src(), edge->src_output()};
    }

    // Outputs.

    }

    @Override
    public String getOutput() {
        outputFeatureCheck.verify();
        return delegateBuildResult.getOutput();
    }

    @Override
    public List<BuildTask> getTasks() {
        return delegateBuildResult.getTasks();
    }

    @Override

import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.TEST_EXECUTION
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.TEST_OUTPUT
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.TRANSFORM_EXECUTION
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.WORK_ITEM_EXECUTION

     */
    String TRANSFORM_EXECUTION = "TRANSFORM_EXECUTION";

    /**
     * The constant for the test output of the task execution operations.
     */
    String TEST_OUTPUT = "TEST_OUTPUT";

    /**
     * The constant for file download operations.
     */
    String FILE_DOWNLOAD = "FILE_DOWNLOAD";

    /**
     * The constant for build phase operations.
     */