bigVal = bigVal.Lsh(bigVal, bitsPerByte).Or(bigVal, big.NewInt(int64(curVal)))
			if valEnd {
				if start == 0 {
					b.WriteString("2.")
					bigVal = bigVal.Sub(bigVal, big.NewInt(80))
				}
				numBuf = bigVal.Append(numBuf, 10)
				b.Write(numBuf)
				numBuf = numBuf[:0]
				val = 0
				start = i + 1
				overflow = false
			}
			continue
		}
		val <<= bitsPerByte
		val |= uint64(curVal)

	m := make(map[BigKey]bool)
	k := BigKey{3, 4, 5}
	m[k] = true
	for i := 0; i < b.N; i++ {
		_ = m[k]
	}
}

type BigVal [3]int64

func BenchmarkBigValMap(b *testing.B) {
	m := make(map[BigKey]BigVal)
	k := BigKey{3, 4, 5}
	m[k] = BigVal{6, 7, 8}
	for i := 0; i < b.N; i++ {
		_ = m[k]
	}
}

func BenchmarkSmallKeyMap(b *testing.B) {
	m := make(map[int16]bool)

)

// Notify causes package signal to relay incoming signals to c.
// If no signals are provided, all incoming signals will be relayed to c.
// Otherwise, just the provided signals will.
//
// Package signal will not block sending to c: the caller must ensure
// that c has sufficient buffer space to keep up with the expected
// signal rate. For a channel used for notification of just one signal value,
// a buffer of size 1 is sufficient.

// must not import anything (like net, but also like os/signal)
// that kicks off background goroutines during init.

package main

import (
	"os/signal"
	"syscall"
)

func init() {
	register("SignalIgnoreSIGTRAP", SignalIgnoreSIGTRAP)
}

func SignalIgnoreSIGTRAP() {
	signal.Ignore(syscall.SIGTRAP)
	syscall.Kill(syscall.Getpid(), syscall.SIGTRAP)
	println("OK")

	// Should die immediately, but we've seen flakiness on various
	// systems (see issue 14063). It's possible that the signal is
	// being delivered to a different thread and we are returning
	// and exiting before that thread runs again. Give the program
	// a little while to die to make sure we pick up the signal
	// before we return and exit the program. The time here
	// shouldn't matter--we'll never really sleep this long.

*/

package runtime

/*
#include <sys/types.h>
#include <sys/event.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/unistd.h>
#include <sys/signal.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
*/
import "C"

const (
	EINTR     = C.EINTR
	EFAULT    = C.EFAULT
	EAGAIN    = C.EAGAIN
	ETIMEDOUT = C.ETIMEDOUT

	O_NONBLOCK = C.O_NONBLOCK

*/

package runtime

/*
#define __DARWIN_UNIX03 0
#include <mach/mach_time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <errno.h>
#include <signal.h>
#include <sys/event.h>
#include <sys/mman.h>
#include <pthread.h>
#include <fcntl.h>
*/
import "C"

const (
	EINTR     = C.EINTR
	EFAULT    = C.EFAULT
	EAGAIN    = C.EAGAIN

	/*  40 */ {_SigNotify, "signal 40"},
	/*  41 */ {_SigNotify, "signal 41"},
	/*  42 */ {_SigNotify, "signal 42"},
	/*  43 */ {_SigNotify, "signal 43"},
	/*  44 */ {_SigNotify, "signal 44"},
	/*  45 */ {_SigNotify, "signal 45"},
	/*  46 */ {_SigNotify, "signal 46"},
	/*  47 */ {_SigNotify, "signal 47"},
	/*  48 */ {_SigNotify, "signal 48"},
	/*  49 */ {_SigNotify, "signal 49"},
	/*  50 */ {_SigNotify, "signal 50"},

		}
	}
}

// signalWaitUntilIdle waits until the signal delivery mechanism is idle.
// This is used to ensure that we do not drop a signal notification due
// to a race between disabling a signal and receiving a signal.
// This assumes that signal delivery has already been disabled for
// the signal(s) in question, and here we are just waiting to make sure

}

// initializationSignalFrom returns an initialization signal function
// which when called signals that watch initialization has already finished
// to priority and fairness dispatcher.
func initializationSignalFrom(ctx context.Context) (InitializationSignal, bool) {
	signal, ok := ctx.Value(priorityAndFairnessInitializationSignalKey).(InitializationSignal)
	return signal, ok && signal != nil
}