println("This expectation for the request [${request.method} :${request.pathInfo}] was already handled - skipping")
                        return
                    }
                    if (!baseRequest.isHandled()) {
                        expectation.atomicRun.set(true)
                        action.handle(request, response)
                        baseRequest.setHandled(true)
                    }
                }

                        return
                    }
                    if (!((Request) request).isHandled()) {
                        expectation.atomicRun.set(true)
                        action.handle(request, response)
                        ((Request) request).setHandled(true)
                    }
                }

		t.Errorf("shift overflow mishandled")
	}
	if one16>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one16u>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8<<N<<N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8u>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
}

// run

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 19710: mishandled defer delete(...)

package main

func main() {
	if n := len(f()); n != 0 {
		println("got", n, "want 0")
		panic("bad defer delete")
	}
}

func f() map[int]bool {
	m := map[int]bool{}
	for i := 0; i < 3; i++ {
		m[i] = true

// compiledir

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Gccgo mishandled type aliases as receiver types.

// compiledir

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Gccgo mishandled an import of a forward declared type.

// compile

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// gccgo mishandled embedded methods of type aliases.

package p

type I int

func (I) M() {}

type T = struct {
	I
}

func F() {
	_ = T.M
	_ = struct { I }.M

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 26120: INDEX of 1-element but non-SSAable array
// is mishandled when building SSA.

package p

type T [1]struct {
	f    []int
	i, j int
}

func F() {
	var v T
	f := func() T {
		return v
	}
	_ = []int{}[f()[0].i]

// compiledir

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Gccgo mishandled a combination of normal import and dot import.

// compiledir

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Gccgo mishandled a reference to a type alias in a package that was
// not directly imported.