// Copyright 2021 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 a

type Pair[L, R any] struct {
	L L
	R R
}

func Two[L, R any](l L, r R) Pair[L, R] {
	return Pair[L, R]{L: l, R: r}
}

type Map[K, V any] interface {
	Put(K, V)
	Len() int
	Iterate(func(Pair[K, V]) bool)
}

type HashMap[K comparable, V any] struct {

// Copyright 2021 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 a

func Conv(v interface{}) string {
	return conv[string](v)
}

func conv[T any](v interface{}) T {
	return v.(T)
}

func Conv2(v interface{}) (string, bool) {
	return conv2[string](v)
}

func conv2[T any](v interface{}) (T, bool) {
	x, ok := v.(T)

apiVersion: v1
kind: Pod
metadata:
  name: a
  labels:
    prune-group: "true"
spec:
  containers:
  - name: kubernetes-pause

// Copyright 2022 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 issue52611a

/*
typedef struct Foo {
    int X;
} Foo;
*/
import "C"

func GetX1(foo *C.struct_Foo) int32 {
	return int32(foo.X)

// Copyright 2018 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 issue23555

// #include <stdlib.h>
import "C"

func X() {
	C.free(C.malloc(10))

// 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

import "runtime"

import "C"

func main() {}

//export GoF

// Copyright 2018 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.

TEXT	·f(SB), 4, $8-0
	CALL	·f1(SB)
	RET	·f2(SB)
	CALL	·unreachable(SB)

TEXT	·leaf(SB), 4, $0-0
	RET	·f3(SB)
	JMP	·unreachable(SB)

TEXT	·leaf2(SB), 4, $32-0 // nonzero frame size
	RET	·f4(SB)

type ApplicativeFunctor1[H Header[HT], HT, A, R any] struct {
	h  Option[H]
	fn Option[Func1[A, R]]
}

func (r ApplicativeFunctor1[H, HT, A, R]) ApOption(a Option[A]) Option[R] {
	return Ap(r.fn, a)
}

func (r ApplicativeFunctor1[H, HT, A, R]) Ap(a A) Option[R] {
	return r.ApOption(Some(a))
}

func Applicative1[A, R any](fn Func1[A, R]) ApplicativeFunctor1[Nil, Nil, A, R] {

// Copyright 2021 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 a

type A[T any] struct {
	a int
}

func (a A[T]) F() {
	_ = &a.a

// Copyright 2022 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 a

type Comparator[T any] func(v1, v2 T) int

func CompareInt[T ~int](a, b T) int {
	if a < b {
		return -1
	}
	if a == b {
		return 0
	}
	return 1