nextLo = c + 1
		}
	}
	for _, xr := range x.R32 {
		lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
		if stride == 1 {
			if nextLo <= lo-1 {
				r = appendRange(r, nextLo, lo-1)
			}
			nextLo = hi + 1
			continue
		}
		for c := lo; c <= hi; c += stride {
			if nextLo <= c-1 {
				r = appendRange(r, nextLo, c-1)
			}
			nextLo = c + 1
		}
	}

            return true;
        }

        int optionalOpen = 0;
        for (int i = 0; i < tokenIndex; i++) {
            char nextChar = patternString.charAt(i);
            if (nextChar == '(') {
                optionalOpen++;
            } else if (nextChar == ')') {
                optionalOpen = Math.max(0, optionalOpen - 1);
            }
        }
        return optionalOpen > 0;
    }

}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}
	return id

/**
 * Provides an id unique within the global scope a build VM.
 */
@ServiceScope(Scope.Global.class)
public interface BuildOperationIdFactory {

    /**
     * @return the next unique ID
     */
    long nextId();

		ppc64.AADDZECC, ppc64.AADDZEVCC, ppc64.AADDZEV, ppc64.AADDZE,
		ppc64.ACNTLZDCC, ppc64.ACNTLZD, ppc64.ACNTLZWCC, ppc64.ACNTLZW,
		ppc64.AEXTSBCC, ppc64.AEXTSB, ppc64.AEXTSHCC, ppc64.AEXTSH,
		ppc64.AEXTSWCC, ppc64.AEXTSW, ppc64.ANEGCC, ppc64.ANEGVCC,
		ppc64.ANEGV, ppc64.ANEG, ppc64.ASLBMFEE, ppc64.ASLBMFEV,
		ppc64.ASLBMTE, ppc64.ASUBMECC, ppc64.ASUBMEVCC, ppc64.ASUBMEV,

    } else {
      BigInteger nextPow = BigInteger.TEN.multiply(approxPow);
      int nextCmp = nextPow.compareTo(x);
      while (nextCmp <= 0) {
        approxLog10++;
        approxPow = nextPow;
        approxCmp = nextCmp;
        nextPow = BigInteger.TEN.multiply(approxPow);
        nextCmp = nextPow.compareTo(x);
      }
    }

    int floorLog = approxLog10;

		case protocol.HBONE:
			return newHBONE(cfg), nil
		case protocol.HTTP, protocol.HTTPS:
			return newHTTP(cfg), nil
		case protocol.HTTP2, protocol.GRPC:
			return newGRPC(cfg), nil
		case protocol.TCP:
			return newTCP(cfg), nil
		case protocol.UDP:
			return newUDP(cfg), nil
		default:
			return nil, fmt.Errorf("unsupported protocol: %s", cfg.Port.Protocol)
		}
	}

	if len(cfg.UDSServer) > 0 {
		return newHTTP(cfg), nil

	Lpid   int32
	Cpid   int32
	Nattch uint32
	_      [4]byte
	_      [4]byte
	_      [4]byte
	_      int32
	_      uint8
	_      uint8
	_      uint16
	_      *byte
	Segsz  uint64
	Atime  Time_t
	Dtime  Time_t
	Ctime  Time_t
}

type SysvShmDesc64 struct {
	Perm   SysvIpcPerm
	_      [4]byte
	Lpid   int32
	Cpid   int32
	Nattch uint32
	_      [4]byte
	_      [4]byte

}

type BlockedArg struct {
	Blocked string `json:"blocked"`
}

type SortIndexArg struct {
	Index int `json:"sort_index"`
}

type HeapCountersArg struct {
	Allocated uint64
	NextGC    uint64
}

const (
	ProcsSection = 0 // where Goroutines or per-P timelines are presented.
	StatsSection = 1 // where counters are presented.
	TasksSection = 2 // where Task hierarchy & timeline is presented.
)

	const PB = 1 << 50
	if v > PB {
		v = 0
	}
	e.heapStats.nextGC = v
	e.emitHeapCounters(ts)
}

func (e *Emitter) emitHeapCounters(ts time.Duration) {
	if e.prevHeapStats == e.heapStats {
		return
	}
	diff := uint64(0)
	if e.heapStats.nextGC > e.heapStats.heapAlloc {
		diff = e.heapStats.nextGC - e.heapStats.heapAlloc
	}
	if e.tsWithinRange(ts) {
		e.OptionalEvent(&format.Event{