recover()
				}()
				defer panic(3)
				panic(2)
			}()
			defer func() {
				recover()
			}()
			panic(1)
		}()
		defer func() {}()
	}()

	var x = 123
	func() {
		// in the original issue, this defer was not executed (which is incorrect)
		defer print(x)
		func() {
			defer func() {}()
			panic(4)
		}()
	}()

		// constant initialization expression, pos is the position of
		// the original expression, and not of the currently declared
		// constant identifier. Use the provided errpos instead.
		// TODO(gri) We may also want to augment the error message and
		// refer to the position (pos) in the original expression.
		if check.errpos != nil && check.errpos.Pos().IsValid() {
			assert(check.iota != nil)

// license that can be found in the LICENSE file.

package math

/*
	Floating-point arctangent.
*/

// The original C code, the long comment, and the constants below were
// from http://netlib.sandia.gov/cephes/cmath/atan.c, available from
// http://www.netlib.org/cephes/cmath.tgz.
// The go code is a version of the original C.
//
// atan.c
// Inverse circular tangent (arctangent)
//
// SYNOPSIS:
// double x, y, atan();

// <******@****.***> found at https://github.com/antonblanchard/crc32-vpmsum.
// The original is dual licensed under GPL and Apache 2.  As the copyright holder
// for the work, IBM has contributed this new work under the golang license.

// This code was written in Go based on the original C implementation.

// This is a tool needed to generate the appropriate constants needed for

func Exp(x float64) float64 {
	if haveArchExp {
		return archExp(x)
	}
	return exp(x)
}

// The original C code, the long comment, and the constants
// below are from FreeBSD's /usr/src/lib/msun/src/e_exp.c
// and came with this notice. The go code is a simplified
// version of the original C.
//
// ====================================================
// Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.

	// file set fset.
	funcAST, fset := parseFunc("example_test.go", "printSelf")

	// Print the function body into buffer buf.
	// The file set is provided to the printer so that it knows
	// about the original source formatting and can add additional
	// line breaks where they were present in the source.
	var buf bytes.Buffer
	printer.Fprint(&buf, fset, funcAST.Body)

	// Remove braces {} enclosing the function body, unindent,

	v = cache.Do(2, func() int { n++; return n })
	if v != 3 {
		t.Fatalf("cache.Do(2) did not run f")
	}
	v = cache.Do(1, func() int { n++; return n })
	if v != 2 {
		t.Fatalf("cache.Do(1) did not returned saved value from original cache.Do(1)")
	}

func sysWriteBits() fs.FileMode {
	// Read current umask. There's no way to read it without also setting it,
	// so set it conservatively and then restore the original one.
	m := syscall.Umask(0o777)
	syscall.Umask(m)    // restore bits
	if m&0o22 == 0o22 { // group and world are unwritable by default
		return 0o700
	}
	if m&0o2 == 0o2 { // group is writable by default, but not world

		return nil, err
	}

	command := exec.Command(cmd, "-S", "-o", "-", gofilename)
	buf, err := command.Output()
	if err != nil {
		return nil, err
	}

	// Original mangling: go.l__ufer.Run
	// Mangling v2: go.l..u00e4ufer.Run
	// Mangling v3: go_0l_u00e4ufer.Run
	if bytes.Contains(buf, []byte("go_0l_u00e4ufer.Run")) {
		return toSymbolV3, nil

		// not feasible to do so at the moment: std-vendored libraries are included
		// in the "std" meta-pattern (because in general they *are* linked into
		// users binaries separately from the original import paths), and we can't
		// allow a binary in the "std" meta-pattern.
		modArgs = []string{"-mod=readonly"}
	} else {
		// Nobody outside the standard library should be using this wrapper: other