// 
PACKAGE d

IMPORTPATH
	testdata/d

FILENAMES
	testdata/d1.go
	testdata/d2.go

CONSTANTS
	// CBx constants should appear before CAx constants. 
	const (
		CB2	= iota	// before CB1
		CB1		// before CB0
		CB0		// at end
	)

	// CAx constants should appear after CBx constants. 
	const (
		CA2	= iota	// before CA1
		CA1		// before CA0
		CA0		// at end
	)

	// C0 should be first. 
	const C0 = 0

			case ld.lockContext <- lkctx:
				// Send the lock context to anyone asking for it
			}
		}
	}
}

func mergeContext(ctx1, ctx2 context.Context) (context.Context, context.CancelFunc) {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		select {
		case <-ctx1.Done():
		case <-ctx2.Done():
		// The lock acquirer decides to cancel, exit this goroutine
		case <-ctx.Done():
		}

		cancel()

		})
		return ctx, func() {
			stop()
			cancel(context.Canceled)
		}
	}

	ctx1, cancel1 := context.WithCancelCause(context.Background())
	defer cancel1(errors.New("ctx1 canceled"))

	ctx2, cancel2 := context.WithCancelCause(context.Background())

	mergedCtx, mergedCancel := mergeCancel(ctx1, ctx2)
	defer mergedCancel()

	cancel2(errors.New("ctx2 canceled"))
	<-mergedCtx.Done()

	// Create a task that starts and ends entirely outside of the trace.
	ctx0, t0 := trace.NewTask(baseCtx, "parent")

	// Create a task that starts before the trace and ends during the trace.
	ctx1, t1 := trace.NewTask(ctx0, "type1")

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	t1.End()

public final class CodeFragment {
    // source: 'fragment.kt'
    public method <init>(): void
    public final static method run(p0: Ctx1, p1: Ctx2): int

const (
	id     = "1234-5678"
	source = "main.go"
)

func testSimpleWriteLock(t *testing.T, duration time.Duration) (locked bool) {
	drwm1 := NewDRWMutex(ds, "simplelock")
	ctx1, cancel1 := context.WithCancel(context.Background())
	if !drwm1.GetRLock(ctx1, cancel1, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

package d

// C2 should be third.
const C2 = 2

// V2 should be third.
var V2 int

// CBx constants should appear before CAx constants.
const (
	CB2 = iota // before CB1
	CB1        // before CB0
	CB0        // at end
)

// VBx variables should appear before VAx variables.
var (
	VB2 int // before VB1
	VB1 int // before VB0
	VB0 int // at end
)

const (

                    cb.specify().columnId();
                });
        final List<String> idList = activeSessionList.stream().map(CrawlingInfo::getId).collect(Collectors.toList());
        crawlingInfoParamBhv.queryDelete(cb1 -> cb1.query().filtered((cq, cf) -> {
            cq.matchAll();
            if (!idList.isEmpty()) {
                cf.not(subCf -> subCf.setCrawlingInfoId_InScope(idList));
            }
        }));

	r := yy1 + 91881*cr1
	if uint32(r)&0xff000000 == 0 {
		r >>= 16
	} else {
		r = ^(r >> 31)
	}

	g := yy1 - 22554*cb1 - 46802*cr1
	if uint32(g)&0xff000000 == 0 {
		g >>= 16
	} else {
		g = ^(g >> 31)
	}

	b := yy1 + 116130*cb1
	if uint32(b)&0xff000000 == 0 {
		b >>= 16
	} else {
		b = ^(b >> 31)
	}

	return uint8(r), uint8(g), uint8(b)
}

				SecurityContext:          securitycontext.ValidSecurityContextWithContainerDefaults(),
				VolumeMounts: []v1.VolumeMount{
					{
						Name:      "ctb-volume",
						MountPath: "/var/run/ctb-volume",
					},
				},
			}},
			Volumes: []v1.Volume{
				{
					Name: "ctb-volume",
					VolumeSource: v1.VolumeSource{
						Projected: &v1.ProjectedVolumeSource{
							Sources: []v1.VolumeProjection{
								{