def branch6 = new DefaultMultiCauseException("sixth failure", intermediateFailure2)

        Throwable exception = new ContextAwareException(new TypedResolveException("task dependencies", "org:example:1.0", [branch1, branch2, branch3, branch4, branch5, branch6]))

        when:
        reporter.buildFinished(result(exception))
        print(output.value)

        then:
        output.value == """

        %result = "tf.Case"(%index, %input) {branches = [@branch_0, @branch_1, @branch_2, @branch_3, @branch_4], is_stateless = false} : (tensor<i32>, tensor<i32>) -> tensor<i32>
        tf_executor.yield %result : tensor<i32>
      }
      tf_executor.fetch %output : tensor<i32>

    }
    func.return %0 : tensor<i32>
  }
  func.func @branch_0(%arg0: tensor<i32>) -> tensor<i32> {

name: Upload SIG Build docker containers modified for release branches

on:
  workflow_dispatch:
  push:
    paths:
      - '.github/workflows/sigbuild-docker-branch.yml'
      - 'tensorflow/tools/tf_sig_build_dockerfiles/**'
      - '!tensorflow/tools/tf_sig_build_dockerfiles/README.md'
    branches:
      - "r[1-9].[0-9]+"

permissions:
  contents: read

jobs:
  docker:

  //
  // Two ops with the same groups and different branches are considered
  // parallel so are not made dependent. For example if `OpA` has parallel_ids
  //   `{group0:branch0, group1:branch0}`
  // and `OpB` has parallel_ids
  //   `{group0:branch1, graph1:branch0}`
  // then `OpA` and `OpB` are executed in parallel because `group0` is common
  // with a different branch.
  //

at 2022-02-02T14:15:21-05:00
git add pkg go.mod
git commit -a -m 'pkg: add empty package'
git branch -m main
git tag 'v0.1.0'

at 2022-02-02T14:19:44-05:00
git branch 'v1.0.0'
git branch 'v2.0.0'
git checkout 'v1.0.0'
cp v1/pkg/pkg.go pkg/pkg.go
git commit -a -m 'pkg: start developing toward v1.0.0'

at 2022-02-03T10:53:13-05:00
git branch 'v3.0.0-devel'
git checkout 'v3.0.0-devel'
git checkout v0.1.0 pkg/pkg.go

	}
	s.f.NamedValues[loc] = append(values, v)
}

// Branch is an unresolved branch.
type Branch struct {
	P *obj.Prog  // branch instruction
	B *ssa.Block // target
}

// State contains state needed during Prog generation.
type State struct {
	ABI obj.ABI

	pp *objw.Progs

	// Branches remembers all the branch instructions we've seen
	// and where they would like to go.

# https://github.com/tensorflow/tensorflow/actions/workflows/release-branch-cherrypick.yml
# and click "Run Workflow." Leave "Use Workflow From" set to "master", then
# input the branch name and paste the cherry-pick commit and click Run. A PR
# will be created.

name: Release Branch Cherrypick
on:
  workflow_dispatch:
    inputs:
      # We use this instead of the "run on branch" argument because GitHub looks

  input: "Case/branch0/_0/mul/y"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "Case/branch1/_1/mul_0"
  op: "Mul"
  input: "Case/Case/input_0/_7:1"
  input: "Case/branch1/_1/mul/y"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "Case/merge/_9"
  op: "Merge"
  input: "Case/branch0/_0/mul_0"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syntax

import "fmt"

// checkBranches checks correct use of labels and branch
// statements (break, continue, fallthrough, goto) in a function body.
// It catches:
//   - misplaced breaks, continues, and fallthroughs
//   - bad labeled breaks and continues

//          which represents the second branch of replicate group 0 and
//          the first branch of parallel group 0.
// First instance of "tf.OpD" after flattening will have
//          `_parallel_execution_ids = "r0:0,p0:1"`
//          which represents the first branch of replicate group 0 and
//          the second branch of parallel group 0.
// Second instance of "tf.OpD" after flattening will have