func printnl()

//go:noescape
func useT40(*T40)

type T40 struct {
	m map[int]int
}

func newT40() *T40 {
	ret := T40{}
	ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$"
	return &ret
}

func bad40() {
	t := newT40() // ERROR "stack object ret T40$" "stack object .autotmp_[0-9]+ runtime.hmap$"
	printnl()     // ERROR "live at call to printnl: ret$"
	useT40(t)
}

type T40 struct {
	m map[int]int
}

//go:noescape
func useT40(*T40)

func newT40() *T40 {
	ret := T40{}
	ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$"
	return &ret
}

func bad40() {
	t := newT40()
	_ = t
	printnl()
}

func good40() {
	ret := T40{}              // ERROR "stack object ret T40$"

type T40 struct {
	m map[int]int
}

//go:noescape
func useT40(*T40)

func newT40() *T40 {
	ret := T40{}
	ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$"
	return &ret
}

func bad40() {
	t := newT40()
	_ = t
	printnl()
}

func good40() {
	ret := T40{}              // ERROR "stack object ret T40$"

	testGolden(t, New32(), golden32)
}

func TestGolden32a(t *testing.T) {
	testGolden(t, New32a(), golden32a)
}

func TestGolden64(t *testing.T) {
	testGolden(t, New64(), golden64)
}

func TestGolden64a(t *testing.T) {
	testGolden(t, New64a(), golden64a)
}

func TestGolden128(t *testing.T) {
	testGolden(t, New128(), golden128)
}

func TestGolden128a(t *testing.T) {
	testGolden(t, New128a(), golden128a)

	var s sum32a = offset32
	return &s
}

// New64 returns a new 64-bit FNV-1 [hash.Hash].
// Its Sum method will lay the value out in big-endian byte order.
func New64() hash.Hash64 {
	var s sum64 = offset64
	return &s
}

// New64a returns a new 64-bit FNV-1a [hash.Hash].
// Its Sum method will lay the value out in big-endian byte order.
func New64a() hash.Hash64 {
	var s sum64a = offset64
	return &s
}

	{"fnv32a", func() hash.Hash { return fnv.New32a() }, fromHex("666e76027439f86f")},
	{"fnv64", func() hash.Hash { return fnv.New64() }, fromHex("666e7603cc64e0e97692c637")},
	{"fnv64a", func() hash.Hash { return fnv.New64a() }, fromHex("666e7604c522af9b0dede66f")},
	{"fnv128", func() hash.Hash { return fnv.New128() }, fromHex("666e760561587a70a0f66d7981dc980e2cabbaf7")},

            // 404
            throw responseManager.new404("Thumbnail for " + form.docId + " is not found.");
        }

        final File thumbnailFile = thumbnailManager.getThumbnailFile(doc);
        if (thumbnailFile == null) {
            if (fessConfig.isThumbnailEnabled()) {
                thumbnailManager.offer(doc);
            }
            // 404

        try {
            final ActionResponse actionResponse = ssoManager.getResponse(SsoResponseType.METADATA);
            if (actionResponse == null) {
                throw responseManager.new400("Unsupported request type.");
            }
            return actionResponse;
        } catch (final SsoMessageException e) {
            if (e.getCause() == null) {
                if (logger.isDebugEnabled()) {

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

package p1

import "./p0"

type T1 interface {
	p0.T0
	m1()
}

type S1 struct {
	p0.S0
}

func (S1) m1() {}

func NewT0() p0.T0 {
	return S1{}
}

func NewT1() T1 {
	return S1{}

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

package main

import (
	"./p0"
	"./p1"
)

var (
	_ p0.T0 = p0.S0{}
	_ p0.T0 = p1.S1{}
	_ p0.T0 = p1.NewT0()
	_ p0.T0 = p1.NewT1() // same as p1.S1{}
)