// run

//go:build !wasm

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// small enough for registers, too large for SSA
type T struct {
	a, b, c, d, e int
}

//go:noinline
func F() {
	a, b := g(), g()
	h(b, b)
	h(a, g())
	if a.a == 1 {
		a = g()
	}
	h(a, a)
}

        "@com_google_absl//absl/status",
        "@com_google_absl//absl/status:statusor",
        "@com_google_absl//absl/strings",
    ],
)

tf_cc_test(
    name = "metrics_test",
    size = "small",
    srcs = ["metrics_test.cc"],
    deps = [
        ":metrics",
        "//tensorflow/core:protos_all_cc",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",

			// Found a matching, unallocated instance. Let's use it.
			//
			// A more thorough search would include backtracking because
			// allocating one "large" instances for a "small" request may
			// make a following "large" request impossible to satisfy when
			// only "small" instances are left.
			instances[i].Allocated = true
			indices = append(indices, i)
			break
		}
	}
	return indices, nil

TEXT	indexbytebody<>(SB), NOSPLIT, $0
	// Shuffle X0 around so that each byte contains
	// the character we're looking for.
	MOVD AX, X0
	PUNPCKLBW X0, X0
	PUNPCKLBW X0, X0
	PSHUFL $0, X0, X0

	CMPQ BX, $16
	JLT small

	MOVQ SI, DI

	CMPQ BX, $32
	JA avx2
sse:
	LEAQ	-16(SI)(BX*1), AX	// AX = address of last 16 bytes
	JMP	sseloopentry

	PCALIGN $16
sseloop:
	// Move the next 16-byte chunk of the data into X1.

    javacopts = ["-XepDisableAllChecks"],
    visibility = ["//visibility:public"],
    deps = [
${subProjectDependencies}
    ]
)

junit_tests(
    name = "tests_for_project${subProjectNumber}",
    size = "small",
    srcs = glob(["src/test/java/**/*.java"]),
    deps = [
        "project${subProjectNumber}",
        ${subProjectDependencies}
    ],
)
"""
        } else {
            """

	JMP	memeqbody<>(SB)

// Input:
//   a in SI
//   b in DI
//   count in BX
// Output:
//   result in AX
TEXT memeqbody<>(SB),NOSPLIT,$0-0
	CMPQ	BX, $8
	JB	small
	CMPQ	BX, $64
	JB	bigloop
#ifndef hasAVX2
	CMPB	internal∕cpu·X86+const_offsetX86HasAVX2(SB), $1
	JE	hugeloop_avx2

	// 64 bytes at a time using xmm registers
	PCALIGN $16
hugeloop:
	CMPQ	BX, $64

// arm64:"TEXT\t.*, [$]0-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// Note: that 386 currently has to spill a register.
func KeepWanted(t *T) {
	*t = T{A: t.A, B: t.B, C: t.C, D: t.D}
}

// Check that small array operations avoid using the stack (issue #15925).

// Notes:
// - 386 fails due to spilling a register
// - arm & mips fail due to softfloat calls
// amd64:"TEXT\t.*, [$]0-"
// arm64:"TEXT\t.*, [$]0-"

		last   netip.Addr
		offset uint64
		want   []string
	}{
		{
			name:   "start from first address small range",
			first:  netip.MustParseAddr("192.168.0.1"),
			last:   netip.MustParseAddr("192.168.0.2"),
			offset: 0,
			want:   []string{"192.168.0.1", "192.168.0.2"},
		}, {
			name:   "start from last address small range",
			first:  netip.MustParseAddr("192.168.0.1"),
			last:   netip.MustParseAddr("192.168.0.2"),

package strings

import (
	"internal/stringslite"
)

// Clone returns a fresh copy of s.
// It guarantees to make a copy of s into a new allocation,
// which can be important when retaining only a small substring
// of a much larger string. Using Clone can help such programs
// use less memory. Of course, since using Clone makes a copy,
// overuse of Clone can make programs use more memory.

        when:
        decode(bytes) { Decoder decoder ->
            decoder.readLong()
        }

        then:
        thrown(EOFException)
    }

    def "can encode and decode a small long"() {
        expect:
        def bytesA = encode { Encoder encoder ->
            encoder.writeSmallLong(a as long)
        }
        def bytesB = encode { Encoder encoder ->