"𝔙":                             "\U0001d519",
	"𝕍":                            "\U0001d54d",
	"𝒱":                            "\U0001d4b1",
	"⊪":                          "\u22aa",
	"Ŵ":                           "\u0174",
	"⋀":                           "\u22c0",
	"𝔚":                             "\U0001d51a",
	"𝕎":                            "\U0001d54e",

			<param name="file.version" value="1.3.2" />
		</antcall>
		<!-- kopf -->
		<get dest="${target.dir}/kopf.zip">
			<url url="https://github.com/codelibs/elasticsearch-kopf/archive/${kopf.branch}.zip" />
		</get>
		<delete dir="${site.dir}/kopf" />
		<unzip dest="${site.dir}/kopf" src="${target.dir}/kopf.zip">
			<patternset>
				<include name="elasticsearch-kopf-${kopf.branch}/_site/**" />
			</patternset>
			<cutdirsmapper dirs="2" />

  hack/lint-dependencies.sh >&2
popd > /dev/null 2>&1

if [[ ${ret} -gt 0 ]]; then
  exit ${ret}
fi

# Ensure we can tidy every repo using only its recorded versions
for repo in $(kube::util::list_staging_repos); do
  pushd "${_kubetmp}/staging/src/k8s.io/${repo}" >/dev/null 2>&1
    echo "Tidying k8s.io/${repo}..."
    GODEBUG=gocacheverify=1 go mod tidy
  popd >/dev/null 2>&1
done

	MOVL	$0x800000, 0(SP)                    // stacksize = 8192KB
	MOVL	$_rt0_386_lib_go(SB), AX
	MOVL	AX, 4(SP)                           // fn
	CALL	runtime·newosproc0(SB)

restore:
	ADDL	$8, SP
	POPL	DI
	POPL	SI
	POPL	BX
	POPL	BP
	RET

// _rt0_386_lib_go initializes the Go runtime.
// This is started in a separate thread by _rt0_386_lib.
TEXT _rt0_386_lib_go(SB),NOSPLIT,$8
	MOVL	_rt0_386_lib_argc<>(SB), AX
	MOVL	AX, 0(SP)

  chmod +x "$2"

  # Make a copy named just "ztunnel" in the same directory (overwrite if necessary).
  echo "Copying $2 to $(dirname "$2")/${3}"
  cp -f "$2" "$(dirname "$2")/${3}"
  popd

  # Also copy it to out/$os_arch/ztunnel as that's whats used in the build
  echo "Copying '${2}' to ${TARGET_OUT_LINUX}/ztunnel"
  cp -f "${2}" "${TARGET_OUT_LINUX}/ztunnel"
}

function maybe_build_ztunnel() {

    echo "Fess is not available."
    cat ${temp_log_file} ./fess-*/logs/*.log
    exit 1
  fi
  sleep 1
done

pushd /tmp >/dev/null
git clone https://github.com/codelibs/fess-testdata.git
popd >/dev/null

cat ${temp_log_file} ./fess-*/logs/*.log
curl -s "http://localhost:9201/_cat/indices?v"

kube::util::trap_add "git worktree remove -f ${WORKTREE}" EXIT

govulncheck -scan module ./... > "${KUBE_TEMP}/head.txt"
pushd "${WORKTREE}" >/dev/null
  govulncheck -scan module ./... > "${KUBE_TEMP}/pr-base.txt"
popd >/dev/null

echo -e "\n HEAD: $(cat "${KUBE_TEMP}"/head.txt)" 
echo -e "\n PR_BASE: $(cat "${KUBE_TEMP}/pr-base.txt")" 

			// If directory entry on stack before this, pop it now.
			for len(dirStack) > 0 && dirStack[len(dirStack)-1] < meta.name {
				pop := dirStack[len(dirStack)-1]
				select {
				case <-ctx.Done():
					return ctx.Err()
				case out <- metaCacheEntry{name: pop}:
				}
				if opts.Recursive {
					// Scan folder we found. Should be in correct sort order where we are.
					err := scanDir(pop)

        while (stack.size() > 1) {
          A right = pop(stack);
          A left = pop(stack);
          push(stack, collector.combiner().apply(left, right));
        }
        return pop(stack);
      }

      <E extends @Nullable Object> void push(List<E> stack, E value) {
        stack.add(value);
      }

      <E extends @Nullable Object> E pop(List<E> stack) {
        return stack.remove(stack.size() - 1);

cp -v ../../../../_output/local/bin/linux/amd64/apiextensions-apiserver ./artifacts/simple-image/apiextensions-apiserver
docker build -t apiextensions-apiserver:latest ./artifacts/simple-image