return true
		}
	}
	return false
}

func hexEscapeNonASCII(s string) string {
	newLen := 0
	for i := 0; i < len(s); i++ {
		if s[i] >= utf8.RuneSelf {
			newLen += 3
		} else {
			newLen++
		}
	}
	if newLen == len(s) {
		return s
	}
	b := make([]byte, 0, newLen)
	var pos int
	for i := 0; i < len(s); i++ {
		if s[i] >= utf8.RuneSelf {
			if pos < i {

		},
		[]byte("Sample message for keylen=blocklen"),
		"5fd596ee78d5553c8ff4e72d266dfd192366da29",
		sha1.Size,
		sha1.BlockSize,
	},
	{
		sha1.New,
		[]byte{
			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
			0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
			0x10, 0x11, 0x12, 0x13,
		},
		[]byte("Sample message for keylen<blocklen"),
		"4c99ff0cb1b31bd33f8431dbaf4d17fcd356a807",

		if uint64(uintptr(unsafe.Pointer(&p[0])))&uint64(vecAlignMask) != 0 {
			align := uint64(uintptr(unsafe.Pointer(&p[0]))) & uint64(vecAlignMask)
			newlen := vecMinLen - align
			crc = ppc64SlicingUpdateBy8(crc, archCastagnoliTable8, p[:newlen])
			p = p[newlen:]
		}
		// p should be aligned now
		aligned := len(p) & ^vecAlignMask
		crc = vectorCrc32(crc, crcCast, p[:aligned])
		p = p[aligned:]
	}
	if len(p) == 0 {

			panic("cryptobyte: internal error")
		}
		var lenLen, lenByte uint8
		if int64(length) > 0xfffffffe {
			b.err = errors.New("pending ASN.1 child too long")
			return
		} else if length > 0xffffff {
			lenLen = 5
			lenByte = 0x80 | 4
		} else if length > 0xffff {
			lenLen = 4
			lenByte = 0x80 | 3
		} else if length > 0xff {
			lenLen = 3
			lenByte = 0x80 | 2
		} else if length > 0x7f {

	if len(packet) < 2 {
		return 0, fmt.Errorf("short write of %d bytes; want 2+", len(packet))
	}
	reqLen := int(packet[0])<<8 | int(packet[1])
	req := packet[2:]
	if len(req) != reqLen {
		return 0, fmt.Errorf("packet declared length %d doesn't match body length %d", reqLen, len(req))
	}

	var parser dnsmessage.Parser
	h, err := parser.Start(req)
	if err != nil {
		// TODO: hook

	decryptedRangeRef := func(s []int64, skipLen, readLen int64, isFromEnd bool) (o, l, skip int64, sn uint32, ps int) {
		oSize := lsum(s)
		if isFromEnd {
			skipLen = oSize - readLen
		}
		if skipLen < 0 || readLen < 0 || oSize < 0 || skipLen+readLen > oSize {
			t.Fatalf("Impossible read specified: %d %d %d", skipLen, readLen, oSize)
		}

		var cumulativeSum, cumulativeEncSum int64

    },
    {
      "matchPackageNames": ["gradle"],
      "allowedVersions": "<8.0",
      "description": "Recent release, not compatible with pinned AGP and Kotlin versions yet. Wait for AGP 8?"
    },
    {
      "matchPackageNames": ["com.android.tools.build:gradle"],
      "allowedVersions": "<7.4",
      "description": "Recent release, no compatible Intellij stable release (2023.1)"
    }
  ]

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *
   * @throws IllegalStateException if there has been a call to {@link #peek()} since the most recent
   *     call to {@link #next()} and this implementation does not support this sequence of calls
   *     (optional)
   */
  @Override
  void remove();

    /**
     * Returns the next group of elements after removing them from the queue.
     *
     * The group contains the most recently pushed element plus all
     * elements superseded by it ordered from most recent to least recent.
     */
    fun nextGroup(timeoutMillis: Long = pollTimeoutMillis): List<T> {
        lock.withLock {
            if (q.isNotEmpty()) {
                return takeNextGroup()
            }

}

type Section struct {
	Rwx     uint8
	Extnum  int16
	Align   int32
	Name    string
	Vaddr   uint64
	Length  uint64
	Seg     *Segment
	Elfsect interface{} // an *ld.ElfShdr
	Reloff  uint64
	Rellen  uint64
	// Relcount is the number of *host* relocations applied to this section
	// (when external linking).
	// Incremented atomically on multiple goroutines.