pkg archive/tar, const TypeChar ideal-char
pkg archive/tar, const TypeCont ideal-char
pkg archive/tar, const TypeDir ideal-char
pkg archive/tar, const TypeFifo ideal-char
pkg archive/tar, const TypeLink ideal-char
pkg archive/tar, const TypeReg ideal-char
pkg archive/tar, const TypeRegA ideal-char
pkg archive/tar, const TypeSymlink ideal-char
pkg archive/tar, const TypeXGlobalHeader ideal-char

			ChangeTime: time.Unix(1441973436, 0),
			Format:     FormatGNU,
		}},
	}, {
		// Matches the behavior of GNU and BSD tar utilities.
		file: "testdata/pax-multi-hdrs.tar",
		headers: []*Header{{
			Name:     "bar",
			Linkname: "PAX4/PAX4/long-linkpath-name",
			ModTime:  time.Unix(0, 0),
			Typeflag: '2',
			PAXRecords: map[string]string{
				"linkpath": "PAX4/PAX4/long-linkpath-name",
			},
			Format: FormatPAX,

func ExampleEqualFold() {
	fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
	// Output: true
}

func ExampleFields() {
	fmt.Printf("Fields are: %q", bytes.Fields([]byte("  foo bar  baz   ")))
	// Output: Fields are: ["foo" "bar" "baz"]
}

func ExampleFieldsFunc() {
	f := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}

pkg syscall (darwin-arm64), const IPPROTO_AX25 = 93
pkg syscall (darwin-arm64), const IPPROTO_AX25 ideal-int
pkg syscall (darwin-arm64), const IPPROTO_BHA = 49
pkg syscall (darwin-arm64), const IPPROTO_BHA ideal-int
pkg syscall (darwin-arm64), const IPPROTO_BLT = 30
pkg syscall (darwin-arm64), const IPPROTO_BLT ideal-int
pkg syscall (darwin-arm64), const IPPROTO_BRSATMON = 76

pkg syscall (freebsd-arm64), const IPPROTO_AX25 = 93
pkg syscall (freebsd-arm64), const IPPROTO_AX25 ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_BHA = 49
pkg syscall (freebsd-arm64), const IPPROTO_BHA ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_BLT = 30
pkg syscall (freebsd-arm64), const IPPROTO_BLT ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_BRSATMON = 76

func TestIndexRune(t *testing.T) {
	tests := []struct {
		in   string
		rune rune
		want int
	}{
		{"", 'a', -1},
		{"", '☺', -1},
		{"foo", '☹', -1},
		{"foo", 'o', 1},
		{"foo☺bar", '☺', 3},
		{"foo☺☻☹bar", '☹', 9},
		{"a A x", 'A', 2},
		{"some_text=some_value", '=', 9},
		{"☺a", 'a', 3},
		{"a☻☺b", '☺', 4},

		// RuneError should match any invalid UTF-8 byte sequence.
		{"�", '�', 0},

	LBAR (R4)(R0),$1,R5             // 7ca02069
	LBAR (R4),$0,R5                 // 7ca02068
	LBAR (R3),R5                    // 7ca01868
	LHAR (R4)(R3*1),$1,R5           // 7ca320e9
	LHAR (R4)(R0),$1,R5             // 7ca020e9
	LHAR (R4),$0,R5                 // 7ca020e8
	LHAR (R3),R5                    // 7ca018e8
	LWAR (R4)(R3*1),$1,R5           // 7ca32029
	LWAR (R4)(R0),$1,R5             // 7ca02029

pkg syscall (freebsd-riscv64), const IPPROTO_AX25 = 93 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_AX25 ideal-int #53466
pkg syscall (freebsd-riscv64), const IPPROTO_BHA = 49 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_BHA ideal-int #53466
pkg syscall (freebsd-riscv64), const IPPROTO_BLT = 30 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_BLT ideal-int #53466

%{
#include <stdio.h>
#include <stdlib.h>
%}

%typemap(gotype) const char * "string"
%typemap(in) const char * %{
	$1 = malloc($input.n + 1);
	memcpy($1, $input.p, $input.n);
	$1[$input.n] = '\0';
%}
%typemap(freearg) const char * %{
	free($1);
%}

FILE *fopen(const char *name, const char *mode);
int fclose(FILE *);

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include <string.h>

#include "_cgo_export.h"

void
callback(void *f)
{
	// use some stack space
	volatile char data[64*1024];

	data[0] = 0;
	goCallback(f);
        data[sizeof(data)-1] = 0;
}

void
callGoFoo(void)
{
	extern void goFoo(void);
	goFoo();
}

void
IntoC(void)
{
	BackIntoGo();