}

type BlockedArg struct {
	Blocked string `json:"blocked"`
}

type SortIndexArg struct {
	Index int `json:"sort_index"`
}

type HeapCountersArg struct {
	Allocated uint64
	NextGC    uint64
}

const (
	ProcsSection = 0 // where Goroutines or per-P timelines are presented.
	StatsSection = 1 // where counters are presented.
	TasksSection = 2 // where Task hierarchy & timeline is presented.
)

		}
		pipe = nextfd
		nextfd++
	}
	for i = 0; i < len(fd); i++ {
		if fd[i] >= 0 && fd[i] < i {
			if nextfd == pipe { // don't stomp on pipe
				nextfd++
			}
			if runtime.GOOS == "openbsd" {
				_, _, err1 = rawSyscall(dupTrampoline, uintptr(fd[i]), uintptr(nextfd), O_CLOEXEC)
			} else {
				_, _, err1 = rawSyscall(dupTrampoline, uintptr(fd[i]), uintptr(nextfd), 0)
				if err1 != 0 {

            InternalTestOutputDescriptor descriptor = new DefaultTestOutputDescriptor(new OperationIdentifier(idFactory.nextId()), buildOperationId);
            int destination = getDestination(progress.getOutput().getDestination());

    }

    private DefaultBuildPhaseDescriptor toBuildOperationDescriptor(BuildOperationDescriptor buildOperation) {
        OperationIdentifier operationId = new OperationIdentifier(idFactory.nextId());
        OperationIdentifier parent = eventConsumer.findStartedParentId(buildOperation);
        String name = buildOperation.getName();
        String displayName = "Build phase: " + buildOperation.getDisplayName();

        int nextChar = next();
        if (nextChar == '\n') {
            return true; // '\\\n' discarded from stream
        } else if (nextChar == '\r') {
            int followingChar = next();
            if (followingChar == '\n') {
                return true; // '\\\r\n' discarded from stream
            }
            pushBack(nextChar);
            pushBack(followingChar);

previous-next-scan.svg...

        return (cmpXToRoundArbitrarily <= 0) ? roundArbitrarily : Math.nextUp(roundArbitrarily);
      case DOWN:
        if (sign(x) >= 0) {
          return (cmpXToRoundArbitrarily >= 0)
              ? roundArbitrarily
              : DoubleUtils.nextDown(roundArbitrarily);
        } else {
          return (cmpXToRoundArbitrarily <= 0) ? roundArbitrarily : Math.nextUp(roundArbitrarily);
        }
      case UP:
        if (sign(x) >= 0) {

    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {
        Supplier<OperationIdentifier> operationIdentifierSupplier = () -> new OperationIdentifier(idFactory.nextId());
        AggregatingProblemConsumer aggregator = new AggregatingProblemConsumer(progressEventConsumer, operationIdentifierSupplier);
        this.problemAggregator = Optional.of(aggregator);

            .details(details)
            .build(newOperationIdentifier(), parentId);
    }

    private OperationIdentifier newOperationIdentifier() {
        return new OperationIdentifier(buildOperationIdFactory.nextId());
    }

    private static class Details implements ExecuteTestBuildOperationType.Details {
        private final TestDescriptor testDescriptor;
        private final long startTime;

        %3 = "tf.A"() : () -> tensor<?xi32>
        tf_device.return %3 : tensor<?xi32>
      }) {device = "/device:test_device:0"} : () -> tensor<?xi32>
    // CHECK: tf_executor.fetch %[[LAUNCH_OUTPUT]]
    tf_executor.fetch %1#0 : tensor<?xi32>
  }
  func.return %0 : tensor<?xi32>
}

// CHECK: func private @[[LAUNCH]]
// CHECK-SAME: () -> tensor<?xi32>
// CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"()