Go is an open source programming language that makes it easy to build simple,
reliable, and efficient software.

![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
*Gopher image by [Renee French][rf], licensed under [Creative Commons 4.0 Attributions license][cc4-by].*

Our canonical Git repository is located at https://go.googlesource.com/go.
There is a mirror of the repository at https://github.com/golang/go.

	writeUleb128(&sb, uint64(len(funcProps.ParamFlags)))
	for _, pf := range funcProps.ParamFlags {
		writeUleb128(&sb, uint64(pf))
	}
	writeUleb128(&sb, uint64(len(funcProps.ResultFlags)))
	for _, rf := range funcProps.ResultFlags {
		writeUleb128(&sb, uint64(rf))
	}
	return sb.String()
}

func DeserializeFromString(s string) *FuncProps {
	if len(s) == 0 {
		return nil
	}
	var funcProps FuncProps
	var v uint64
	sl := []byte(s)

	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

type ft func() *int

var fn ft

func rf([]reflect.Value) []reflect.Value {
	a := reflect.ValueOf((*int)(nil))
	return []reflect.Value{a}
}

const N = 1000

func main() {
	fn = reflect.MakeFunc(reflect.TypeOf(fn), rf).Interface().(ft)

	// Keep running GC so the write barrier is on.
	go func() {
		for i := 0; i < N; i++ {
			runtime.GC()

	}
	outf := []*types.Field{}
	for _, ot := range outs {
		outf = append(outf, mkParamResultField(ot, q, ir.PPARAMOUT))
	}
	var rf *types.Field
	if rcvr != nil {
		rf = mkParamResultField(rcvr, q, ir.PPARAM)
	}
	return types.NewSignature(rf, inf, outf)
}

type expectedDump struct {
	dump string
	file string
	line int
}

func tokenize(src string) []string {
	var s scanner.Scanner

[!root] ! cp $WORK/extraneous.txt $GOPATH/pkg/mod/rsc.io/quote@v1.5.2/go.mod

# If all 'go' commands ran with the flag, the system's 'rm' binary
# should be able to remove the module cache if the '-rf' flags are set.
[!GOOS:windows] [exec:rm] exec rm -rf $GOPATH/pkg/mod
[!GOOS:windows] [!exec:rm] go clean -modcache
[GOOS:windows] [exec:cmd.exe] exec cmd.exe /c rmdir /s /q $GOPATH\pkg\mod
[GOOS:windows] [!exec:cmd.exe] go clean -modcache

COPY jwtconf.ini .
COPY sample-RSA-private.pem .
COPY sample-RSA-public.pem .
RUN chmod +x ./run.sh && chmod +x jwt_tool.py && apt-get update && apt-get install --no-install-recommends -y python3-pip \
  && apt-get clean && rm -rf /var/lib/apt/lists/*
RUN python3 -m pip install --no-cache-dir termcolor==1.1.0 cprint==1.2.2 pycryptodomex==3.10.1 requests==2.25.1

  chmod -R +w "${_tmpdir}"
  if [ "${KEEP_TMP}" == "true" ]; then
    echo "Leaving ${_tmpdir} for you to examine or copy. Please delete it manually when finished. (rm -rf ${_tmpdir})"
  else
    echo "Removing ${_tmpdir}"
    rm -rf "${_tmpdir}"
  fi
}
kube::util::trap_add cleanup EXIT

# Copy the contents of the kube directory into the nice clean place (which is NOT shaped like a GOPATH)

#	./update.bash
#
# If it prints "No updates needed.", then the generated files
# in the CL match the update.bash in the CL.

# Versions to use.
CODE=2024a
DATA=2024a

set -e

cd $(dirname $0)
rm -rf work
mkdir work
go build -o work/mkzip mkzip.go # build now for correct paths in build errors
cd work
mkdir zoneinfo
curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz

  "doc_tmp"
  "test/e2e/generated/bindata.go"
)

for item in "${CLEAN_PATTERNS[@]}"; do
  # Shellcheck wants the ":?" because of paranoia about 'rm -rf /'. It will
  # cause an error if unset, which is already true because of "nounset", but
  # belts AND suspenders is fine for this.
  rm -rf "${KUBE_ROOT:?}/${item:?}"
done

# https://squidfunk.github.io/mkdocs-material/
# It requires python3 to run.

set -ex

REPO="******@****.***:square/okhttp.git"
DIR=temp-clone

# Delete any existing temporary website clone
rm -rf $DIR

# Clone the current repo into temp folder
git clone $REPO $DIR
# Replace `git clone` with these lines to hack on the website locally
# cp -a . "../okhttp-website"
# mv "../okhttp-website" "$DIR"