// allocation if the budget runs low.
	spanBudget := 100

	var s *mspan
	var sl sweepLocker

	// Try partial swept spans first.
	sg := mheap_.sweepgen
	if s = c.partialSwept(sg).pop(); s != nil {
		goto havespan
	}

	sl = sweep.active.begin()
	if sl.valid {
		// Now try partial unswept spans.
		for ; spanBudget >= 0; spanBudget-- {
			s = c.partialUnswept(sg).pop()
			if s == nil {
				break
			}

package bytealg

import _ "unsafe" // for go:linkname

func Compare(a, b []byte) int {
	l := len(a)
	if len(b) < l {
		l = len(b)
	}
	if l == 0 || &a[0] == &b[0] {
		goto samebytes
	}
	for i := 0; i < l; i++ {
		c1, c2 := a[i], b[i]
		if c1 < c2 {
			return -1
		}
		if c1 > c2 {
			return +1
		}
	}
samebytes:
	if len(a) < len(b) {
		return -1
	}

        <keyword>enum</keyword>
        <keyword>extends</keyword>
        <keyword>false</keyword>
        <keyword>final</keyword>
        <keyword>finally</keyword>
        <keyword>for</keyword>
        <keyword>goto</keyword>
        <keyword>if</keyword>
        <keyword>implements</keyword>
        <keyword>import</keyword>
        <keyword>in</keyword>
        <keyword>instanceof</keyword>
        <keyword>interface</keyword>

        <keyword>else</keyword>
        <keyword>extends</keyword>
        <keyword>final</keyword>
        <keyword>finally</keyword>
        <keyword>float</keyword>
        <keyword>for</keyword>
        <keyword>goto</keyword>
        <keyword>if</keyword>
        <keyword>implements</keyword>
        <keyword>import</keyword>
        <keyword>instanceof</keyword>
        <keyword>int</keyword>
        <keyword>interface</keyword>

func ToFold(s string) string {
	// Fast path: all ASCII, no upper case.
	// Most paths look like this already.
	for i := 0; i < len(s); i++ {
		c := s[i]
		if c >= utf8.RuneSelf || 'A' <= c && c <= 'Z' {
			goto Slow
		}
	}
	return s

Slow:
	var b strings.Builder
	for _, r := range s {
		// SimpleFold(x) cycles to the next equivalent rune > x
		// or wraps around to smaller values. Iterate until it wraps,

	//   (c) If there's nothing left to advance, goto (1).
	// (6) Select the latest event for the selected M and get it ready to be returned.
	// (7) Read the next event for the selected M and update the min-heap.
	// (8) Return the selected event, goto (5) on the next call.

	// Set us up to track the last timestamp and fix up
	// the timestamp of any event that comes through.

		f, err := os.Open(file)
		if err != nil {
			log.Fatal(err)
		}
		aro, err := archive.Parse(f, false)
		if err != nil || !isGoCompilerObjFile(aro) {
			f.Seek(0, io.SeekStart)
			ar.addFile(f)
			goto close
		}

		for _, e := range aro.Entries {
			if e.Type != archive.EntryGoObj || e.Name != "_go_.o" {
				continue
			}

@echo off

if DEFINED JAVA_HOME goto cont

:err
ECHO JAVA_HOME environment variable must be set! 1>&2
EXIT /B 1 

:cont
set SCRIPT_DIR=%~dp0
for %%I in ("%SCRIPT_DIR%..") do set FESS_HOME=%%~dpfI


REM ***** JAVA options *****

if "%FESS_MIN_MEM%" == "" (
set FESS_MIN_MEM=256m
)

if "%FESS_MAX_MEM%" == "" (
set FESS_MAX_MEM=1g
)

if NOT "%FESS_HEAP_SIZE%" == "" (
set FESS_MIN_MEM=%FESS_HEAP_SIZE%

		if call, ok := syntax.Unparen(s.X).(*syntax.CallExpr); ok && check.isPanic[call] {
			return true
		}

	case *syntax.ReturnStmt:
		return true

	case *syntax.BranchStmt:
		if s.Tok == syntax.Goto || s.Tok == syntax.Fallthrough {
			return true
		}

	case *syntax.BlockStmt:
		return check.isTerminatingList(s.List, "")

	case *syntax.IfStmt:
		if s.Else != nil &&
			check.isTerminating(s.Then, "") &&

		if call, ok := ast.Unparen(s.X).(*ast.CallExpr); ok && check.isPanic[call] {
			return true
		}

	case *ast.ReturnStmt:
		return true

	case *ast.BranchStmt:
		if s.Tok == token.GOTO || s.Tok == token.FALLTHROUGH {
			return true
		}

	case *ast.BlockStmt:
		return check.isTerminatingList(s.List, "")

	case *ast.IfStmt:
		if s.Else != nil &&
			check.isTerminating(s.Body, "") &&