#SNG: from basn0g01-30.png
IHDR {
    width: 30; height: 30; bitdepth: 8;
    using grayscale;
}
gAMA {1.0000}
IMAGE {
    pixels hex
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000
ffffffff0000ffffffffffff0000ffffffffffffffffffffffffff000000

	\v             vertical tab character (== \013)
	\*             literal *, for any punctuation character *
	\123           octal character code (up to three digits)
	\x7F           hex character code (exactly two digits)
	\x{10FFFF}     hex character code
	\Q...\E        literal text ... even if ... has punctuation

Character class elements:

	x              single character
	A-Z            character range (inclusive)

}

// compareSignatureV4 returns true if and only if both signatures
// are equal. The signatures are expected to be HEX encoded strings
// according to the AWS S3 signature V4 spec.
func compareSignatureV4(sig1, sig2 string) bool {
	// The CTC using []byte(str) works because the hex encoding
	// is unique for a sequence of bytes. See also compareSignatureV2.
	return subtle.ConstantTimeCompare([]byte(sig1), []byte(sig2)) == 1

// This test tests some internals of the flate package.
// The tests in package compress/gzip serve as the
// end-to-end test of the decompressor.

package flate

import (
	"bytes"
	"encoding/hex"
	"io"
	"strings"
	"testing"
)

// The following test should not panic.
func TestIssue5915(t *testing.T) {
	bits := []int{4, 0, 0, 6, 4, 3, 2, 3, 3, 4, 4, 5, 0, 0, 0, 0, 5, 5, 6,

    (255,  0,187)     # rgb = (0xff,0x00,0xbb)
    (255,187,  0)     # rgb = (0xff,0xbb,0x00)
    (  0, 68,255)     # rgb = (0x00,0x44,0xff)
    (  0,255, 68)     # rgb = (0x00,0xff,0x44)
}
IMAGE {
    pixels hex
88885555ccccaaaa77773333eeee9999
88885555ccccaaaa77773333eeee9999
88885555ccccaaaa77773333eeee9999
88885555ccccaaaa77773333eeee9999
5555ccccaaaa77773333eeee99991111
5555ccccaaaa77773333eeee99991111

PLTE {
    (  0,255,  0)     # rgb = (0x00,0xff,0x00)
    (255,  0,  0)     # rgb = (0xff,0x00,0x00)
    (255,255,  0)     # rgb = (0xff,0xff,0x00)
    (  0,  0,255)     # rgb = (0x00,0x00,0xff)
}
IMAGE {
    pixels hex
ff55aa00ff55aa00
ff55aa00ff55aa00
ff55aa00ff55aa00
ff55aa00ff55aa00
00ff55aa00ff55aa
00ff55aa00ff55aa
00ff55aa00ff55aa
00ff55aa00ff55aa
aa00ff55aa00ff55
aa00ff55aa00ff55
aa00ff55aa00ff55

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"context"
	"crypto/md5"
	"encoding/hex"
	"strings"
	"testing"
)

// Wrapper for calling DeleteObject tests for both Erasure multiple disks and single node setup.
func TestDeleteObject(t *testing.T) {
	ExecObjectLayerTest(t, testDeleteObject)
}

// license that can be found in the LICENSE file.

package hpke

import (
	"bytes"
	"encoding/hex"
	"encoding/json"
	"os"
	"strconv"
	"strings"
	"testing"

	"crypto/ecdh"
	_ "crypto/sha256"
	_ "crypto/sha512"
)

func mustDecodeHex(t *testing.T, in string) []byte {
	b, err := hex.DecodeString(in)
	if err != nil {
		t.Fatal(err)
	}
	return b
}

			var first [17]int
			rng := rand.New(rand.NewSource(0))
			var tmp [16]byte
			rng.Read(tmp[:])
			prefix := hex.EncodeToString(tmp[:])
			for i := 0; i < 10000; i++ {
				rng.Read(tmp[:])

				y := hashOrder(fmt.Sprintf("%s/%x", prefix, hex.EncodeToString(tmp[:3])), x)
				first[y[0]]++
			}
			t.Log("first:", first[:x])
		})
	}

	}

	// Optional base prefix.
	hex := false
	if len(s) >= 2 && s[0] == '0' && (lower(s[1]) == 'b' || lower(s[1]) == 'o' || lower(s[1]) == 'x') {
		i = 2
		saw = '0' // base prefix counts as a digit for "underscore as digit separator"
		hex = lower(s[1]) == 'x'
	}

	// Number proper.
	for ; i < len(s); i++ {
		// Digits are always okay.
		if '0' <= s[i] && s[i] <= '9' || hex && 'a' <= lower(s[i]) && lower(s[i]) <= 'f' {