<p>
            We check the binary compatibility by comparing the current code’s binary interfaces
            against THE LATEST VERSION WHICH IS RELEASED FROM RELEASE BRANCH (from `released-version.json` on this branch)
            AND LOWER THAN CURRENT BASE VERSION (from `version.txt` on this branch).

//
// Note that "go test -json" takes care of invoking test2json correctly,
// so "go tool test2json" is only needed when a test binary is being run
// separately from "go test". Use "go test -json" whenever possible.
//
// Note also that test2json is only intended for converting a single test
// binary's output. To convert the output of a "go test" command that
// runs multiple packages, again use "go test -json".
//
// # Output Format
//

  }

  @Test
  @TestMetadata("jvmNameOnGetter.kt")
  public void testJvmNameOnGetter() {
    runTest("analysis/analysis-api/testData/standalone/binary/jvmNameOnGetter.kt");
  }

  @Test
  @TestMetadata("jvmNameOnSetter.kt")
  public void testJvmNameOnSetter() {
    runTest("analysis/analysis-api/testData/standalone/binary/jvmNameOnSetter.kt");
  }

  @Test

			if strings.Contains(string(out), denylist) {
				t.Fatalf("binary contains unexpected flags: %v", string(out))
			}
		}
	})
}

// Test that binary sizes do not bloat
func TestBinarySizes(t *testing.T) {
	cases := map[string]struct {
		minMb int64
		maxMb int64
	}{
		// TODO: shrink the ranges here once the active work to reduce binary size is complete

    public abstract fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession

    // The `analyse` functions affect binary compatibility as they are inlined with every `analyze` call. To avoid breaking binary
    // compatibility, their implementations should not be changed unless absolutely necessary. It should be possible to put most

}

func SuiteID(kemID, kdfID, aeadID uint16) []byte {
	suiteID := make([]byte, 0, 4+2+2+2)
	suiteID = append(suiteID, []byte("HPKE")...)
	suiteID = binary.BigEndian.AppendUint16(suiteID, kemID)
	suiteID = binary.BigEndian.AppendUint16(suiteID, kdfID)
	suiteID = binary.BigEndian.AppendUint16(suiteID, aeadID)
	return suiteID
}

func ParseHPKEPublicKey(kemID uint16, bytes []byte) (*ecdh.PublicKey, error) {

      port: 9095
      targetPort: grpc
      protocol: TCP
  selector:
    app.kubernetes.io/name: loki
    app.kubernetes.io/instance: loki
    app.kubernetes.io/component: single-binary
---
# Source: loki/templates/single-binary/statefulset.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: loki
  namespace: istio-system
  labels:
    helm.sh/chart: loki-6.6.3
    app.kubernetes.io/name: loki

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

package sha3

import (
	"crypto/subtle"
	"encoding/binary"
	"unsafe"

	"golang.org/x/sys/cpu"
)

// xorIn xors the bytes in buf into the state.
func xorIn(d *state, buf []byte) {
	if cpu.IsBigEndian {
		for i := 0; len(buf) >= 8; i++ {
			a := binary.LittleEndian.Uint64(buf)
			d.a[i] ^= a
			buf = buf[8:]
		}
	} else {

//
// Usage:
//
//	go tool objdump [-s symregexp] binary
//
// Objdump prints a disassembly of all text symbols (code) in the binary.
// If the -s option is present, objdump only disassembles
// symbols with names matching the regular expression.
//
// Alternate usage:
//
//	go tool objdump binary start end
//
// In this mode, objdump disassembles the binary starting at the start address and

		return fmt.Errorf("error seeking in patchSegmentHeader: %v", err)
	}
	if cfw.debug {
		fmt.Fprintf(os.Stderr, "=-= writing counter segment header: %+v", cfw.csh)
	}
	if err := binary.Write(ws, binary.LittleEndian, cfw.csh); err != nil {
		return err
	}
	// ... and finally return to the original offset.
	if _, err := ws.Seek(off, io.SeekStart); err != nil {