//	1e23-8388608
	//	1e23+8388608
	// The former has an even mantissa, so "1e23" rounds to 1e23-8388608.
	// If "1e23+8388608" is implemented as "1e23" + "8388608",
	// that ends up computing 1e23-8388608 + 8388608 = 1e23,
	// which rounds back to 1e23-8388608.
	// The correct answer, of course, would be "1e23+8388608" = 1e23+8388608.

// 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.

// wasm is excluded because the compiler chatter about register abi pragma ends up
// on stdout, and causes the expected output to not match.

package main

import (
	"fmt"
)

var sink *string

type stringPair struct {
	a, b string
}

type stringPairPair struct {

}

// Implemented in runtime package.
func runtime_BeforeFork()
func runtime_AfterFork()
func runtime_AfterForkInChild()

// Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child.
// If a dup or exec fails, write the errno error to pipe.
// (Pipe is close-on-exec so if exec succeeds, it will be closed.)
// In the child, this function must not acquire any locks, because

.386
.model    flat

PUBLIC    _${methodName}
_TEXT     SEGMENT
_${methodName}    PROC
mov    eax, DWORD PTR 4[esp]
add    eax, DWORD PTR 8[esp]
ret    0
_${methodName}    ENDP
_TEXT   ENDS
END
"""
        }else{
            return """
.text
.globl  _${methodName}
_${methodName}:
movl    8(%esp), %eax
addl    4(%esp), %eax
ret
"""

        }
    }

	// Skip CRC
	if maj > 1 || min >= 2 {
		_, metaBuf, err = msgp.ReadUint32Bytes(metaBuf)
		storageLogIf(GlobalContext, err)
	}
	//   =  input - current pos
	ends := len(buf) - len(metaBuf)
	if ends > len(buf) {
		return buf
	}

	return buf[:ends]

// 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.

// wasm is excluded because the compiler chatter about register abi pragma ends up
// on stdout, and causes the expected output to not match.

package main

import "fmt"

// This test is designed to provoke a stack growth
// in a way that very likely leaves junk in the

package main

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
)

func main() {
	dir := os.Args[1]
	ents, err := os.ReadDir(dir)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	for _, ent := range ents {
		name := filepath.Join(dir, ent.Name())
		if good, err := checkCacheFile(name); err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)

// interface method set is sorted as { a.m(); b.m() }.
//
// However, while compiling package b, its package path is set to "",
// so the code produced for F2 uses { b.m(); a.m() } as the method set
// order. So again, it ends up calling the wrong method.
//
// Also, this function is marked noinline because it's critical to the
// test that the interface method call happen in this compilation
// unit, and the itab construction happens in c.go.
//

//go:generate stringer -type lcEventSrc -trimprefix lcEventSrc_ $GOFILE
type lcEventSrc uint8

//revive:disable:var-naming Underscores is used here to indicate where common prefix ends and the enumeration name begins
const (
	lcEventSrc_None lcEventSrc = iota
	lcEventSrc_Heal
	lcEventSrc_Scanner
	lcEventSrc_Decom
	lcEventSrc_Rebal
	lcEventSrc_s3HeadObject
	lcEventSrc_s3GetObject

	default:
		s = append(s, "_html_template_attrescaper")
	}
	e.editActionNode(n, s)
	return c
}

// ensurePipelineContains ensures that the pipeline ends with the commands with
// the identifiers in s in order. If the pipeline ends with a predefined escaper
// (i.e. "html" or "urlquery"), merge it with the identifiers in s.
func ensurePipelineContains(p *parse.PipeNode, s []string) {
	if len(s) == 0 {