w.WriteHeader(201)
				w.WriteHeader(202)
				w.Write([]byte("hi"))
			},
			check(hasStatus(201), hasContents("hi")),
		},
		{
			"write sends 200",
			func(w http.ResponseWriter, r *http.Request) {
				w.Write([]byte("hi first"))
				w.WriteHeader(201)
				w.WriteHeader(202)
			},
			check(hasStatus(200), hasContents("hi first"), hasFlush(false)),
		},
		{
			"write string",

		// at this level because the full block is needed to compute the summary for
		// the next level.
		lo, hi := addrsToSummaryRange(l, base, limit)
		_, hi = blockAlignSummaryRange(l, lo, hi)
		if hi > len(p.summary[l]) {
			p.summary[l] = p.summary[l][:hi]
		}
	}
}

// sysInit initializes the scavengeIndex' chunks array.
//
// Returns the amount of memory added to sysStat.

}

// Lookup returns the Info with the given name.
func Lookup(name string) *Info {
	// binary search, avoiding import of sort.
	lo := 0
	hi := len(All)
	for lo < hi {
		m := int(uint(lo+hi) >> 1)
		mid := All[m].Name
		if name == mid {
			return &All[m]
		}
		if name < mid {
			hi = m
		} else {
			lo = m + 1
		}
	}
	return nil

)

type Empty struct {
	f1, f2 *byte
	empty struct{}
}

func F(e Empty, s []string) {
	if len(s) != 1 || s[0] != "hi" {
		panic("bad slice")
	}
}

func main() {
	reflect.ValueOf(F).Call([]reflect.Value{
		reflect.ValueOf(Empty{}),
		reflect.ValueOf([]string{"hi"}),
	})

	println(s)
	return ResourceFunc{}
}

//go:noinline
func (r SubscriptionAssignmentResource) Hi() ResourceFunc {
	rf := r.base.f("Hello world")
	rf.base = r.base
	return rf
}

func main() {
	var r SubscriptionAssignmentResource
	r.Hi()

		var hi, lo float64
		if absx < Ln2HalfX3 { // and |x| < 1.5 * ln2
			if !sign {
				hi = x - Ln2Hi
				lo = Ln2Lo
				k = 1
			} else {
				hi = x + Ln2Hi
				lo = -Ln2Lo
				k = -1
			}
		} else {
			if !sign {
				k = int(InvLn2*x + 0.5)
			} else {
				k = int(InvLn2*x - 0.5)
			}
			t := float64(k)
			hi = x - t*Ln2Hi // t * Ln2Hi is exact here

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

package main

var t []int
var s string;
var m map[string]int;

func main() {
	println(t["hi"]); // ERROR "non-integer slice index|must be integer|cannot convert"
	println(s["hi"]); // ERROR "non-integer string index|must be integer|cannot convert"
	println(m[0]);    // ERROR "cannot use.*as type string|cannot convert|cannot use"

		b.addMappingEntry(0, 0, 0, "", "", true)
	}
}

func readMainModuleMapping() (start, end uint64, exe, buildID string, err error) {
	first := true
	ok := machVMInfo(func(lo, hi, off uint64, file, build string) {
		if first {
			start, end = lo, hi
			exe, buildID = file, build
		}
		// May see multiple text segments if rosetta is used for running
		// the go toolchain itself.
		first = false
	})
	if !ok {

type uint128 struct {
	lo, hi uint64
}

// mul64 returns a * b.
func mul64(a, b uint64) uint128 {
	hi, lo := bits.Mul64(a, b)
	return uint128{lo, hi}
}

// addMul64 returns v + a * b.
func addMul64(v uint128, a, b uint64) uint128 {
	hi, lo := bits.Mul64(a, b)
	lo, c := bits.Add64(lo, v.lo, 0)
	hi, _ = bits.Add64(hi, v.hi, c)
	return uint128{lo, hi}
}

        this.greeter = greeter
    }

    @Override
    SourceFile getSourceFile() {
        sourceFile("swift", "main.swift", """
            func main() -> Int {
        #if WITH_FEATURE
              print("hi from main")
        #endif
              let greeter = Greeter()
              greeter.sayHello()
              return 0
            }

            _ = main()
        """)
    }