// of edges. An edge connects two nodes. Both nodes and edges must be
// comparable. This is an undirected simple graph.
type _Graph[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]] struct {
	nodes []_Node
}

// _NodeC is the constraints on a node in a graph, given the _Edge type.
type _NodeC[_Edge any] interface {
	comparable
	Edges() []_Edge
}

// _EdgeC is the constraints on an edge in a graph, given the _Node type.

and strip off the leading four-byte kubernetes protobuf header to get standard protobuf that can be decoded:

```sh
cd staging/src/k8s.io/api/testdata/v1.14.0/
diff -u \
  <(tail -c +5 admission.k8s.io.v1beta1.AdmissionReview.pb | protoc --decode_raw) \
  <(tail -c +5 admission.k8s.io.v1beta1.AdmissionReview.after_roundtrip.pb | protoc --decode_raw)
```

> ```diff

import (
	"flag"
)

var (
	fooFlag = flag.String("foo", "", "this should be ok")
	foo     = flag.Lookup("foo")

	barFlag = flag.String("bar", "", "this should be also ok, but is "+notOK()+".")
	bar     = flag.Lookup("bar")
)

func notOK() string {
	return "not OK"
}

-- m_test.go --

package main

import (
	"testing"
)

func TestFoo(t *testing.T) {
	if foo == nil {
		t.Fatal()
	}
}

    }

    def "can transport broken multicause exception"() {
        def ok = new RuntimeException("broken 1")
        def notOk = new ExceptionWithNonSerializableField("broken 2", new RuntimeException("broken 3"))
        def original = new MultiCauseExceptionWithExceptionField("original", notOk, [ok, notOk])

        when:
        def transported = transport(original)

        then:

<component name="ProjectDictionaryState">
  <dictionary name="geevee">
    <words>
      <w>builtins</w>
      <w>callables</w>
      <w>klass</w>
      <w>proto</w>
      <w>protoc</w>
      <w>protos</w>
      <w>ubuntu</w>
    </words>
  </dictionary>

// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.27.1
// 	protoc        v3.18.0
// source: pkg/test/config/mock_config.proto

// Basic config resource consisting
// of a set of key-value pairs

package config

import (

			for _, spec := range d.Specs {
				if spec, ok := spec.(*ast.ValueSpec); ok {
					b.add(spec)
				}
			}
		}

	case *ast.LabeledStmt:
		label = b.labeledBlock(s.Label, s)
		b.jump(label._goto)
		b.current = label._goto
		_s = s.Stmt
		goto start // effectively: tailcall stmt(g, s.Stmt, label)

	case *ast.ReturnStmt:
		b.add(s)
		b.current = b.newBlock(KindUnreachable, s)

	case *ast.BranchStmt:

	bytes = []byte{1, 2, 3, 4, 5}
	ints  = []int32{1, 2, 3, 4, 5}

	five = 5

	ok = true
)

func notOK() {
	if ok {
		println("BUG:")
		ok = false
	}
}

func checkString(desc, s string) {
	p1 := *(*uintptr)(unsafe.Pointer(&s))
	p2 := *(*uintptr)(unsafe.Pointer(&hello))
	if p1-p2 >= 5 {
		notOK()
		println("string", desc, "has invalid base")
	}
}

func checkBytes(desc string, s []byte) {

    def "report with problem loads successfully"() {
        given:
        buildFile '''
            tasks.register('notOk') {
                doLast { println project.name }
            }
        '''

        when:
        configurationCacheFails 'notOk'

        then:
        def configurationCacheReport = resolveConfigurationCacheReport(testDirectory, failure.error)

	_Continue    // continue
	_Default     // default
	_Defer       // defer
	_Else        // else
	_Fallthrough // fallthrough
	_For         // for
	_Func        // func
	_Go          // go
	_Goto        // goto
	_If          // if
	_Import      // import
	_Interface   // interface
	_Map         // map
	_Package     // package
	_Range       // range
	_Return      // return
	_Select      // select