)

# Sometimes Bazel reports darwin_x86_64 as "darwin" and sometimes as
# "darwin_x86_64". The former shows up when building on a Mac x86_64 host for a Mac x86_64 target.
# The latter shows up when cross-compiling for Mac x86_64 from a Mac ARM machine and in internal
# Google builds.
config_setting(
    name = "macos_x86_64_default",
    constraint_values = if_google(

build:android_arm64 --fat_apk_cpu=arm64-v8a
build:android_x86 --config=android
build:android_x86 --cpu=x86
build:android_x86 --fat_apk_cpu=x86
build:android_x86_64 --config=android
build:android_x86_64 --cpu=x86_64
build:android_x86_64 --fat_apk_cpu=x86_64

# Build everything statically for Android since all static libs are later
# bundled together into a single .so for deployment.
build:android --dynamic_mode=off

	VPSHRDQ $64, Z3, Z26, K1, Z13                      // 6273ad4173eb40
	VPSHRDQ $64, Z0, Z26, K1, Z13                      // 6273ad4173e840
	VPSHRDQ $64, -7(CX)(DX*1), Z26, K1, Z13            // 6273ad4173ac11f9ffffff40
	VPSHRDQ $64, -15(R14)(R15*4), Z26, K1, Z13         // 6213ad4173acbef1ffffff40
	VPSHRDQ $64, Z3, Z3, K1, Z13                       // 6273e54973eb40

				b.Fatal("bad equal")
			}
		}
		buf1[n-1] = '\x00'
		buf2[n-1] = '\x00'
	}
}

func BenchmarkEqualBothUnaligned(b *testing.B) {
	sizes := []int{64, 4 << 10}
	if !isRaceBuilder {
		sizes = append(sizes, []int{4 << 20, 64 << 20}...)
	}
	maxSize := 2 * (sizes[len(sizes)-1] + 8)
	if len(bmbuf) < maxSize {
		bmbuf = make([]byte, maxSize)
	}

	for _, n := range sizes {

	blockSizeStr := r.Form.Get("blocksize")
	fileSizeStr := r.Form.Get("filesize")

	blockSize, err := strconv.ParseUint(blockSizeStr, 10, 64)
	if err != nil {
		blockSize = 4 * humanize.MiByte // default value
	}

	fileSize, err := strconv.ParseUint(fileSizeStr, 10, 64)
	if err != nil {
		fileSize = 1 * humanize.GiByte // default value
	}

	opts := madmin.DriveSpeedTestOpts{
		Serial:    serial,

		return []string{"-m31"}
	case "s390x":
		return []string{"-m64"}
	case "mips64", "mips64le":
		if gomips64 == "hardfloat" {
			return []string{"-mabi=64", "-mhard-float"}
		} else if gomips64 == "softfloat" {
			return []string{"-mabi=64", "-msoft-float"}
		}
	case "mips", "mipsle":
		if gomips == "hardfloat" {
			return []string{"-mabi=32", "-mfp32", "-mhard-float", "-mno-odd-spreg"}

                sids[ ai ] = aces[ ai ].getSID();
            }

            for ( int off = 0; off < sids.length; off += 64 ) {
                int len = sids.length - off;
                if ( len > 64 )
                    len = 64;

                getContext().getSIDResolver().resolveSids(getContext(), server, sids, off, len);
            }
        }
        else {

	VSLI	$63, V7.D2, V8.D2               // e8547f6f
	VUSRA	$8, V2.B16, V3.B16              // 4314086f
	VUSRA	$16, V3.H4, V4.H4               // 6414102f
	VUSRA	$32, V5.S4, V6.S4               // a614206f
	VUSRA	$64, V7.D2, V8.D2               // e814406f
	VTBL	V22.B16, [V28.B16, V29.B16], V11.B16                                    // 8b23164e
	VTBL	V18.B8, [V17.B16, V18.B16, V19.B16], V22.B8                             // 3642120e

	{"7", func(b *Reader) string { return reads(b, 7) }},
	{"bytes", readBytes},
	{"lines", readLines},
}

const minReadBufferSize = 16

var bufsizes = []int{
	0, minReadBufferSize, 23, 32, 46, 64, 93, 128, 1024, 4096,
}

func TestReader(t *testing.T) {
	var texts [31]string
	str := ""
	all := ""
	for i := 0; i < len(texts)-1; i++ {
		texts[i] = str + "\n"
		all += texts[i]

  std::unique_ptr<RandomAccessFile> read_file;
  status = env_->NewRandomAccessFile(filepath, &read_file);
  if (!status.ok())
    GTEST_SKIP() << "NewRandomAccessFile() not supported: " << status;

  char scratch[64 /* big enough to accommodate test_data */] = {0};
  StringPiece result;
  status = read_file->Read(0, test_data.size(), &result, scratch);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);