pax_global_header 0000666 0000000 0000000 00000000064 15207302613 0014511 g ustar 00root root 0000000 0000000 52 comment=ceeadf7e25a7ba4efc51def70037b84fabd7a1e0
golang-github-ebitengine-purego-0.10.1/ 0000775 0000000 0000000 00000000000 15207302613 0017725 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/.github/ 0000775 0000000 0000000 00000000000 15207302613 0021265 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 15207302613 0023450 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/.github/ISSUE_TEMPLATE/00-bug.yml 0000664 0000000 0000000 00000002032 15207302613 0025162 0 ustar 00root root 0000000 0000000 name: Bug Report
description: Report a bug you've found.
labels: bug
body:
- type: input
id: version_of_purego
attributes:
label: PureGo Version
validations:
required: true
- type: checkboxes
id: os
attributes:
label: Operating System
options:
- label: Windows
- label: macOS
- label: Linux
- label: FreeBSD
- label: NetBSD
- label: Android
- label: iOS
validations:
required: true
- type: input
id: version_of_go
attributes:
label: Go Version (`go version`)
validations:
required: true
- type: textarea
id: repro_steps
attributes:
label: What steps will reproduce the problem?
validations:
required: true
- type: textarea
id: expected_result
attributes:
label: What is the expected result?
validations:
required: true
- type: textarea
id: actual_result
attributes:
label: What happens instead?
validations:
required: true
- type: textarea
id: additional
attributes:
label: Anything else you feel useful to add?
golang-github-ebitengine-purego-0.10.1/.github/ISSUE_TEMPLATE/01-feature.yml 0000664 0000000 0000000 00000001067 15207302613 0026050 0 ustar 00root root 0000000 0000000 name: Feature Request
description: Provide details about a feature you'd like to see.
labels:
- feature
- request
body:
- type: checkboxes
id: os
attributes:
label: Operating System
options:
- label: Windows
- label: macOS
- label: Linux
- label: FreeBSD
- label: Android
- label: iOS
validations:
required: true
- type: textarea
id: what
attributes:
label: What feature would you like to be added?
validations:
required: true
- type: textarea
id: why
attributes:
label: Why is this needed?
golang-github-ebitengine-purego-0.10.1/.github/ISSUE_TEMPLATE/config.yml 0000664 0000000 0000000 00000000306 15207302613 0025437 0 ustar 00root root 0000000 0000000 blank_issues_enabled: false
contact_links:
- name: Questions
about: Please use one of the forums for questions or general discussions
url: https://github.com/ebitengine/purego/discussions
golang-github-ebitengine-purego-0.10.1/.github/PULL_REQUEST_TEMPLATE.md 0000664 0000000 0000000 00000000541 15207302613 0025066 0 ustar 00root root 0000000 0000000
# What issue is this addressing?
## What _type_ of issue is this addressing?
## What this PR does | solves
golang-github-ebitengine-purego-0.10.1/.github/scripts/ 0000775 0000000 0000000 00000000000 15207302613 0022754 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/.github/scripts/bsd_tests.sh 0000775 0000000 0000000 00000005235 15207302613 0025312 0 ustar 00root root 0000000 0000000 #!/bin/sh -e
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: 2025 The Ebitengine Authors
# BSD tests run within QEMU on Ubuntu.
# vmactions/*-vm only supports a single "step" where it
# brings down the VM at the end of the step, so all
# the commands to run need to be put into this single block.
echo "Running tests on $(uname -a) at $PWD"
PATH=$PATH:/usr/local/go/bin/
# verify Go is available
go version
echo "=> go build"
go build -v ./...
# Compile without optimization to check potential stack overflow.
# The option '-gcflags=all=-N -l' is often used at Visual Studio Code.
# See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch and the issue hajimehoshi/ebiten#2120.
go build "-gcflags=all=-N -l" -v ./...
# Check cross-compiling Windows binaries.
env GOOS=windows GOARCH=386 go build -v ./...
env GOOS=windows GOARCH=amd64 go build -v ./...
env GOOS=windows GOARCH=arm64 go build -v ./...
# Check cross-compiling macOS binaries.
env GOOS=darwin GOARCH=amd64 go build -v ./...
env GOOS=darwin GOARCH=arm64 go build -v ./...
# Check cross-compiling Linux binaries.
env GOOS=linux GOARCH=amd64 go build -v ./...
env GOOS=linux GOARCH=arm64 go build -v ./...
# Check cross-compiling FreeBSD binaries.
env GOOS=freebsd GOARCH=amd64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./...
env GOOS=freebsd GOARCH=arm64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./...
# Check cross-compiling NetBSD binaries.
env GOOS=netbsd GOARCH=amd64 go build -v ./...
env GOOS=netbsd GOARCH=arm64 go build -v ./...
echo "=> go build (plugin)"
# Make sure that plugin buildmode works since we save the R15 register (#254)
go build -buildmode=plugin ./examples/libc
echo "=> go mod vendor"
mkdir /tmp/vendoring
cd /tmp/vendoring
go mod init foo
echo 'package main' > main.go
echo 'import (' >> main.go
echo ' _ "github.com/ebitengine/purego"' >> main.go
echo ')' >> main.go
echo 'func main() {}' >> main.go
go mod edit -replace github.com/ebitengine/purego=$GITHUB_WORKSPACE
go mod tidy
go mod vendor
go build -v .
cd $GITHUB_WORKSPACE
echo "=> go test CGO_ENABLED=0"
env CGO_ENABLED=0 go test -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -shuffle=on -v -count=10 ./...
echo "=> go test CGO_ENABLED=1"
env CGO_ENABLED=1 go test -shuffle=on -v -count=10 ./...
echo "=> go test CGO_ENABLED=0 w/o optimization"
env CGO_ENABLED=0 go test "-gcflags=all=-N -l -std" -v ./...
echo "=> go test CGO_ENABLED=1 w/o optimization"
env CGO_ENABLED=1 go test "-gcflags=all=-N -l" -v ./...
if [ -z "$(go version | grep '^1.1')" ]; then
echo "=> go test race"
go test -race -shuffle=on -v -count=10 ./...
fi
golang-github-ebitengine-purego-0.10.1/.github/workflows/ 0000775 0000000 0000000 00000000000 15207302613 0023322 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/.github/workflows/test.yml 0000664 0000000 0000000 00000026174 15207302613 0025036 0 ustar 00root root 0000000 0000000 name: Test
on: [push, pull_request]
jobs:
test:
strategy:
matrix:
os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
go: ['1.18.x', '1.19.x', '1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x', '1.25.x', '1.26.x']
name: Test with Go ${{ matrix.go }} on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
defaults:
run:
shell: bash
steps:
- name: Git
run: |
# See actions/checkout#135
git config --global core.autocrlf false
git config --global core.eol lf
- name: Checkout
uses: actions/checkout@v5
- name: Setup Go
uses: actions/setup-go@v6
with:
go-version: ${{ matrix.go }}
- name: Set up the prerequisites
if: runner.os == 'Windows'
uses: msys2/setup-msys2@v2
- name: go vet
run: |
env CGO_ENABLED=0 go vet -v ./...
- name: gofmt
run: test -z "$(gofmt -s -l .)"
- name: go build
run: |
go build -v ./...
# Compile without optimization to check potential stack overflow.
# The option '-gcflags=all=-N -l' is often used at Visual Studio Code.
# See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch and the issue hajimehoshi/ebiten#2120.
go build "-gcflags=all=-N -l" -v ./...
# Check cross-compiling Windows binaries.
env GOOS=windows GOARCH=386 go build -v ./...
env GOOS=windows GOARCH=amd64 go build -v ./...
env GOOS=windows GOARCH=arm64 go build -v ./...
# Check cross-compiling macOS binaries.
env GOOS=darwin GOARCH=amd64 go build -v ./...
env GOOS=darwin GOARCH=arm64 go build -v ./...
# Check cross-compiling Linux binaries.
env GOOS=linux GOARCH=amd64 go build -v ./...
env GOOS=linux GOARCH=arm64 go build -v ./...
# Check cross-compiling FreeBSD binaries.
# gcflags -std is necessary to make fakecgo the Cgo for
# FreeBSD to add the symbols that libc.so depends on.
env GOOS=freebsd GOARCH=amd64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./...
env GOOS=freebsd GOARCH=arm64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./...
# Check cross-compiling NetBSD binaries.
env GOOS=netbsd GOARCH=amd64 go build -v ./...
env GOOS=netbsd GOARCH=arm64 go build -v ./...
- name: go build (Linux minor architectures)
# Test them only on the latest Go to reduce CI time.
# s390x cannot be tested here as it requires Cgo.
if: startsWith(matrix.go, '1.26.')
run: |
# Check cross-compiling Linux binaries for minor architectures.
env GOOS=linux GOARCH=loong64 go build -v ./...
env GOOS=linux GOARCH=ppc64le go build -v ./...
env GOOS=linux GOARCH=riscv64 go build -v ./...
- name: go build (plugin)
if: runner.os == 'Linux' || runner.os == 'macOS'
run:
# Make sure that plugin buildmode works since we save the R15 register (#254)
go build -buildmode=plugin ./examples/libc
- name: go mod vendor
if: runner.os != 'Linux'
run: |
mkdir /tmp/vendoring
cd /tmp/vendoring
go mod init foo
echo 'package main' > main.go
echo 'import (' >> main.go
echo ' _ "github.com/ebitengine/purego"' >> main.go
echo ')' >> main.go
echo 'func main() {}' >> main.go
go mod edit -replace github.com/ebitengine/purego=$GITHUB_WORKSPACE
go mod tidy
go mod vendor
go build -v .
- name: go test
run: |
env CGO_ENABLED=0 go test -shuffle=on -v -count=10 ./...
env CGO_ENABLED=1 go test -shuffle=on -v -count=10 ./...
# Compile without optimization to check potential stack overflow.
# The option '-gcflags=all=-N -l' is often used at Visual Studio Code.
# See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch.
env CGO_ENABLED=0 go test "-gcflags=all=-N -l" -v ./...
env CGO_ENABLED=1 go test "-gcflags=all=-N -l" -v ./...
- name: go test (Windows 386)
if: runner.os == 'Windows'
run: |
env CGO_ENABLED=0 GOARCH=386 go test -shuffle=on -v -count=10 ./...
env CGO_ENABLED=1 GOARCH=386 go test -shuffle=on -v -count=10 ./...
- name: go test (Linux 386)
if: ${{ runner.os == 'Linux' && runner.arch != 'ARM64' }}
run: |
sudo apt-get update
sudo apt-get install gcc-multilib
sudo apt-get install g++-multilib
env CGO_ENABLED=0 GOARCH=386 go test -shuffle=on -v -count=10 ./...
env CGO_ENABLED=1 GOARCH=386 go test -shuffle=on -v -count=10 ./...
- name: go test (Linux arm)
if: ${{ runner.os == 'Linux' && runner.arch == 'ARM64' }}
run: |
sudo apt-get update
sudo apt-get install -y qemu-user gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf libc6-armhf-cross
# Create symlink for the dynamic linker that QEMU expects
sudo ln -sf /usr/arm-linux-gnueabihf/lib/ld-linux-armhf.so.3 /lib/ld-linux.so.3
go env -w CC=arm-linux-gnueabihf-gcc
go env -w CXX=arm-linux-gnueabihf-g++
env GOOS=linux GOARCH=arm CGO_ENABLED=0 go test -c -o=purego-test-nocgo .
env QEMU_LD_PREFIX=/usr/arm-linux-gnueabihf qemu-arm ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10
env GOOS=linux GOARCH=arm CGO_ENABLED=1 go test -c -o=purego-test-cgo .
env QEMU_LD_PREFIX=/usr/arm-linux-gnueabihf qemu-arm ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
go env -u CC
go env -u CXX
- name: go test race (no Cgo)
if: ${{ runner.os == 'macOS' && !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') }}
run: |
# -race usually requires Cgo, but macOS is an exception. See https://go.dev/doc/articles/race_detector#Requirements
env CGO_ENABLED=0 go test -race -shuffle=on -v -count=10 ./...
- name: go test race (Cgo)
if: ${{ !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') }}
run: |
env CGO_ENABLED=1 go test -race -shuffle=on -v -count=10 ./...
minor-arches:
strategy:
matrix:
# Test them only on the latest Go to reduce CI time.
go: ['1.26.x']
name: Test with Go ${{ matrix.go }} on Linux minor architectures
runs-on: ubuntu-latest
defaults:
run:
shell: bash
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Setup Go
uses: actions/setup-go@v6
with:
go-version: ${{ matrix.go }}
- name: Set up the prerequisites
run: |
sudo apt-get update
sudo apt-get install -y \
gcc-14-loongarch64-linux-gnu g++-14-loongarch64-linux-gnu \
gcc-powerpc64le-linux-gnu g++-powerpc64le-linux-gnu \
gcc-riscv64-linux-gnu g++-riscv64-linux-gnu \
gcc-s390x-linux-gnu g++-s390x-linux-gnu \
qemu-user
- name: go test (Linux loong64)
run: |
go env -w CC=loongarch64-linux-gnu-gcc-14
go env -w CXX=loongarch64-linux-gnu-g++-14
env GOOS=linux GOARCH=loong64 CGO_ENABLED=0 go test -c -o=purego-test-nocgo .
env QEMU_LD_PREFIX=/usr/loongarch64-linux-gnu qemu-loongarch64 ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10
env GOOS=linux GOARCH=loong64 CGO_ENABLED=1 go test -c -o=purego-test-cgo .
env QEMU_LD_PREFIX=/usr/loongarch64-linux-gnu qemu-loongarch64 ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
go env -u CC
go env -u CXX
- name: go test (Linux ppc64le)
run: |
go env -w CC=powerpc64le-linux-gnu-gcc
go env -w CXX=powerpc64le-linux-gnu-g++
env GOOS=linux GOARCH=ppc64le CGO_ENABLED=0 go test -c -o=purego-test-nocgo .
env QEMU_LD_PREFIX=/usr/powerpc64le-linux-gnu qemu-ppc64le ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10
env GOOS=linux GOARCH=ppc64le CGO_ENABLED=1 go test -c -o=purego-test-cgo .
env QEMU_LD_PREFIX=/usr/powerpc64le-linux-gnu qemu-ppc64le ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
go env -u CC
go env -u CXX
- name: go test (Linux riscv64)
run: |
go env -w CC=riscv64-linux-gnu-gcc
go env -w CXX=riscv64-linux-gnu-g++
# Create symlink for the dynamic linker that QEMU expects
sudo ln -sf /usr/riscv64-linux-gnu/lib/ld-linux-riscv64-lp64d.so.1 /lib/ld.so.1
env GOOS=linux GOARCH=riscv64 CGO_ENABLED=0 go test -c -o=purego-test-nocgo .
env QEMU_LD_PREFIX=/usr/riscv64-linux-gnu qemu-riscv64 ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10
env GOOS=linux GOARCH=riscv64 CGO_ENABLED=1 go test -c -o=purego-test-cgo .
env QEMU_LD_PREFIX=/usr/riscv64-linux-gnu qemu-riscv64 ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
go env -u CC
go env -u CXX
- name: go test (Linux s390x)
run: |
go env -w CC=s390x-linux-gnu-gcc
go env -w CXX=s390x-linux-gnu-g++
env GOOS=linux GOARCH=s390x CGO_ENABLED=1 go test -c -o=purego-test-cgo .
env QEMU_LD_PREFIX=/usr/s390x-linux-gnu qemu-s390x ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
go env -u CC
go env -u CXX
bsd:
strategy:
matrix:
os: ['FreeBSD'] # TODO: Add 'NetBSD' again (#304)
go: ['1.18.10', '1.19.13', '1.20.14', '1.21.13', '1.22.12', '1.23.12', '1.24.13', '1.25.7', '1.26.0']
exclude:
# there are no prebuilt download links for these versions of Go for NetBSD
- os: NetBSD
go: '1.18.10'
- os: NetBSD
go: '1.19.13'
- os: NetBSD
go: '1.20.14'
name: Test with Go ${{ matrix.go }} on ${{ matrix.os }}
runs-on: ubuntu-22.04
defaults:
run:
shell: bash
steps:
- uses: actions/checkout@v5
- name: Run in FreeBSD
if: matrix.os == 'FreeBSD'
uses: vmactions/freebsd-vm@v1
with:
usesh: true
prepare: |
fetch https://go.dev/dl/go${{matrix.go}}.freebsd-amd64.tar.gz
rm -fr /usr/local/go && tar -C /usr/local -xf go${{matrix.go}}.freebsd-amd64.tar.gz
chmod +x $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh
run: $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh
- name: Run in NetBSD
if: matrix.os == 'NetBSD'
uses: vmactions/netbsd-vm@v1
with:
usesh: true
prepare: |
ftp https://go.dev/dl/go${{matrix.go}}.netbsd-amd64.tar.gz
mkdir /usr/local
rm -fr /usr/local/go && tar -C /usr/local -xf go${{matrix.go}}.netbsd-amd64.tar.gz
chmod +x $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh
run: $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh
golang-github-ebitengine-purego-0.10.1/.gitignore 0000664 0000000 0000000 00000000003 15207302613 0021706 0 ustar 00root root 0000000 0000000 *~
golang-github-ebitengine-purego-0.10.1/LICENSE 0000664 0000000 0000000 00000026135 15207302613 0020741 0 ustar 00root root 0000000 0000000 Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
golang-github-ebitengine-purego-0.10.1/README.md 0000664 0000000 0000000 00000011342 15207302613 0021205 0 ustar 00root root 0000000 0000000 # purego
[](https://pkg.go.dev/github.com/ebitengine/purego?GOOS=darwin)
A library for calling C functions from Go without Cgo.
> This is beta software so expect bugs and potentially API breaking changes
> but each release will be tagged to avoid breaking people's code.
> Bug reports are encouraged.
## Motivation
The [Ebitengine](https://github.com/hajimehoshi/ebiten) game engine was ported to use only Go on Windows. This enabled
cross-compiling to Windows from any other operating system simply by setting `GOOS=windows`. The purego project was
born to bring that same vision to the other platforms supported by Ebitengine.
## Benefits
- **Simple Cross-Compilation**: No C means you can build for other platforms easily without a C compiler.
- **Faster Compilation**: Efficiently cache your entirely Go builds.
- **Smaller Binaries**: Using Cgo generates a C wrapper function for each C function called. Purego doesn't!
- **Dynamic Linking**: Load symbols at runtime and use it as a plugin system.
- **Foreign Function Interface**: Call into other languages that are compiled into shared objects.
- **Cgo Fallback**: Works even with CGO_ENABLED=1 so incremental porting is possible.
This also means unsupported GOARCHs (freebsd/riscv64, linux/mips, etc.) will still work
except for float arguments and return values.
## Supported Platforms
### Tier 1
Tier 1 platforms are the primary targets officially supported by PureGo. When a new version of PureGo is released, any critical bugs found on Tier 1 platforms are treated as release blockers. The release will be postponed until such issues are resolved.
- **Android**: amd641, arm641
- **iOS**: amd641, arm641
- **Linux**: amd64, arm64
- **macOS**: amd64, arm64
- **Windows**: amd64, arm64
### Tier 2
Tier 2 platforms are supported by PureGo on a best-effort basis. Critical bugs on Tier 2 platforms do not block new PureGo releases. However, fixes contributed by external contributors are very welcome and encouraged.
- **Android**: 3861, arm1
- **FreeBSD**: amd642, arm642
- **Linux**: 386, arm, loong64, ppc64le, riscv64, s390x1
- **Windows**: 3863, arm3,4
#### Support Notes
1. These architectures require CGO_ENABLED=1 to compile
2. These architectures require the special flag `-gcflags="github.com/ebitengine/purego/internal/fakecgo=-std"` to compile with CGO_ENABLED=0
3. These architectures only support `SyscallN` and `NewCallback`
4. These architectures are no longer supported as of Go 1.26
## Example
The example below only showcases purego use for macOS and Linux. The other platforms require special handling which can
be seen in the complete example at [examples/libc](https://github.com/ebitengine/purego/tree/main/examples/libc) which supports FreeBSD and Windows.
```go
package main
import (
"fmt"
"runtime"
"github.com/ebitengine/purego"
)
func getSystemLibrary() string {
switch runtime.GOOS {
case "darwin":
return "/usr/lib/libSystem.B.dylib"
case "linux":
return "libc.so.6"
default:
panic(fmt.Errorf("GOOS=%s is not supported", runtime.GOOS))
}
}
func main() {
libc, err := purego.Dlopen(getSystemLibrary(), purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
panic(err)
}
var puts func(string)
purego.RegisterLibFunc(&puts, libc, "puts")
puts("Calling C from Go without Cgo!")
}
```
Then to run: `CGO_ENABLED=0 go run main.go`
## Questions
If you have questions about how to incorporate purego in your project or want to discuss
how it works join the [Discord](https://discord.gg/HzGZVD6BkY)!
### External Code
Purego uses code that originates from the Go runtime. These files are under the BSD-3
License that can be found [in the Go Source](https://github.com/golang/go/blob/master/LICENSE).
This is a list of the copied files:
* `abi_*.h` from package `runtime/cgo`
* `wincallback.go` from package `runtime`
* `zcallback_darwin_*.s` from package `runtime`
* `internal/fakecgo/abi_*.h` from package `runtime/cgo`
* `internal/fakecgo/asm_GOARCH.s` from package `runtime/cgo`
* `internal/fakecgo/callbacks.go` from package `runtime/cgo`
* `internal/fakecgo/iscgo.go` from package `runtime/cgo`
* `internal/fakecgo/setenv.go` from package `runtime/cgo`
* `internal/fakecgo/freebsd.go` from package `runtime/cgo`
* `internal/fakecgo/netbsd.go` from package `runtime/cgo`
The `internal/fakecgo/go_GOOS.go` files were modified from `runtime/cgo/gcc_GOOS_GOARCH.go`.
The files `abi_*.h` and `internal/fakecgo/abi_*.h` are the same because Bazel does not support cross-package use of
`#include` so we need each one once per package. (cf. [issue](https://github.com/bazelbuild/rules_go/issues/3636))
golang-github-ebitengine-purego-0.10.1/abi_amd64.h 0000664 0000000 0000000 00000005353 15207302613 0021632 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These save the frame pointer, so in general, functions that use
// these should have zero frame size to suppress the automatic frame
// pointer, though it's harmless to not do this.
#ifdef GOOS_windows
// REGS_HOST_TO_ABI0_STACK is the stack bytes used by
// PUSH_REGS_HOST_TO_ABI0.
#define REGS_HOST_TO_ABI0_STACK (28*8 + 8)
// PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from
// the host ABI to Go ABI0 code. It saves all registers that are
// callee-save in the host ABI and caller-save in Go ABI0 and prepares
// for entry to Go.
//
// Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag.
// Clear the DF flag for the Go ABI.
// MXCSR matches the Go ABI, so we don't have to set that,
// and Go doesn't modify it, so we don't have to save it.
#define PUSH_REGS_HOST_TO_ABI0() \
PUSHFQ \
CLD \
ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \
MOVQ DI, (0*0)(SP) \
MOVQ SI, (1*8)(SP) \
MOVQ BP, (2*8)(SP) \
MOVQ BX, (3*8)(SP) \
MOVQ R12, (4*8)(SP) \
MOVQ R13, (5*8)(SP) \
MOVQ R14, (6*8)(SP) \
MOVQ R15, (7*8)(SP) \
MOVUPS X6, (8*8)(SP) \
MOVUPS X7, (10*8)(SP) \
MOVUPS X8, (12*8)(SP) \
MOVUPS X9, (14*8)(SP) \
MOVUPS X10, (16*8)(SP) \
MOVUPS X11, (18*8)(SP) \
MOVUPS X12, (20*8)(SP) \
MOVUPS X13, (22*8)(SP) \
MOVUPS X14, (24*8)(SP) \
MOVUPS X15, (26*8)(SP)
#define POP_REGS_HOST_TO_ABI0() \
MOVQ (0*0)(SP), DI \
MOVQ (1*8)(SP), SI \
MOVQ (2*8)(SP), BP \
MOVQ (3*8)(SP), BX \
MOVQ (4*8)(SP), R12 \
MOVQ (5*8)(SP), R13 \
MOVQ (6*8)(SP), R14 \
MOVQ (7*8)(SP), R15 \
MOVUPS (8*8)(SP), X6 \
MOVUPS (10*8)(SP), X7 \
MOVUPS (12*8)(SP), X8 \
MOVUPS (14*8)(SP), X9 \
MOVUPS (16*8)(SP), X10 \
MOVUPS (18*8)(SP), X11 \
MOVUPS (20*8)(SP), X12 \
MOVUPS (22*8)(SP), X13 \
MOVUPS (24*8)(SP), X14 \
MOVUPS (26*8)(SP), X15 \
ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \
POPFQ
#else
// SysV ABI
#define REGS_HOST_TO_ABI0_STACK (6*8)
// SysV MXCSR matches the Go ABI, so we don't have to set that,
// and Go doesn't modify it, so we don't have to save it.
// Both SysV and Go require DF to be cleared, so that's already clear.
// The SysV and Go frame pointer conventions are compatible.
#define PUSH_REGS_HOST_TO_ABI0() \
ADJSP $(REGS_HOST_TO_ABI0_STACK) \
MOVQ BP, (5*8)(SP) \
LEAQ (5*8)(SP), BP \
MOVQ BX, (0*8)(SP) \
MOVQ R12, (1*8)(SP) \
MOVQ R13, (2*8)(SP) \
MOVQ R14, (3*8)(SP) \
MOVQ R15, (4*8)(SP)
#define POP_REGS_HOST_TO_ABI0() \
MOVQ (0*8)(SP), BX \
MOVQ (1*8)(SP), R12 \
MOVQ (2*8)(SP), R13 \
MOVQ (3*8)(SP), R14 \
MOVQ (4*8)(SP), R15 \
MOVQ (5*8)(SP), BP \
ADJSP $-(REGS_HOST_TO_ABI0_STACK)
#endif
golang-github-ebitengine-purego-0.10.1/abi_arm64.h 0000664 0000000 0000000 00000002767 15207302613 0021656 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These macros save and restore the callee-saved registers
// from the stack, but they don't adjust stack pointer, so
// the user should prepare stack space in advance.
// SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space
// of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP).
//
// SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space
// of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP).
//
// R29 is not saved because Go will save and restore it.
#define SAVE_R19_TO_R28(offset) \
STP (R19, R20), ((offset)+0*8)(RSP) \
STP (R21, R22), ((offset)+2*8)(RSP) \
STP (R23, R24), ((offset)+4*8)(RSP) \
STP (R25, R26), ((offset)+6*8)(RSP) \
STP (R27, g), ((offset)+8*8)(RSP)
#define RESTORE_R19_TO_R28(offset) \
LDP ((offset)+0*8)(RSP), (R19, R20) \
LDP ((offset)+2*8)(RSP), (R21, R22) \
LDP ((offset)+4*8)(RSP), (R23, R24) \
LDP ((offset)+6*8)(RSP), (R25, R26) \
LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */
#define SAVE_F8_TO_F15(offset) \
FSTPD (F8, F9), ((offset)+0*8)(RSP) \
FSTPD (F10, F11), ((offset)+2*8)(RSP) \
FSTPD (F12, F13), ((offset)+4*8)(RSP) \
FSTPD (F14, F15), ((offset)+6*8)(RSP)
#define RESTORE_F8_TO_F15(offset) \
FLDPD ((offset)+0*8)(RSP), (F8, F9) \
FLDPD ((offset)+2*8)(RSP), (F10, F11) \
FLDPD ((offset)+4*8)(RSP), (F12, F13) \
FLDPD ((offset)+6*8)(RSP), (F14, F15)
golang-github-ebitengine-purego-0.10.1/abi_loong64.h 0000664 0000000 0000000 00000003712 15207302613 0022204 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These macros save and restore the callee-saved registers
// from the stack, but they don't adjust stack pointer, so
// the user should prepare stack space in advance.
// SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space
// of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3).
//
// SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space
// of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3).
//
// Note: g is R22
#define SAVE_R22_TO_R31(offset) \
MOVV g, ((offset)+(0*8))(R3) \
MOVV R23, ((offset)+(1*8))(R3) \
MOVV R24, ((offset)+(2*8))(R3) \
MOVV R25, ((offset)+(3*8))(R3) \
MOVV R26, ((offset)+(4*8))(R3) \
MOVV R27, ((offset)+(5*8))(R3) \
MOVV R28, ((offset)+(6*8))(R3) \
MOVV R29, ((offset)+(7*8))(R3) \
MOVV R30, ((offset)+(8*8))(R3) \
MOVV R31, ((offset)+(9*8))(R3)
#define SAVE_F24_TO_F31(offset) \
MOVD F24, ((offset)+(0*8))(R3) \
MOVD F25, ((offset)+(1*8))(R3) \
MOVD F26, ((offset)+(2*8))(R3) \
MOVD F27, ((offset)+(3*8))(R3) \
MOVD F28, ((offset)+(4*8))(R3) \
MOVD F29, ((offset)+(5*8))(R3) \
MOVD F30, ((offset)+(6*8))(R3) \
MOVD F31, ((offset)+(7*8))(R3)
#define RESTORE_R22_TO_R31(offset) \
MOVV ((offset)+(0*8))(R3), g \
MOVV ((offset)+(1*8))(R3), R23 \
MOVV ((offset)+(2*8))(R3), R24 \
MOVV ((offset)+(3*8))(R3), R25 \
MOVV ((offset)+(4*8))(R3), R26 \
MOVV ((offset)+(5*8))(R3), R27 \
MOVV ((offset)+(6*8))(R3), R28 \
MOVV ((offset)+(7*8))(R3), R29 \
MOVV ((offset)+(8*8))(R3), R30 \
MOVV ((offset)+(9*8))(R3), R31
#define RESTORE_F24_TO_F31(offset) \
MOVD ((offset)+(0*8))(R3), F24 \
MOVD ((offset)+(1*8))(R3), F25 \
MOVD ((offset)+(2*8))(R3), F26 \
MOVD ((offset)+(3*8))(R3), F27 \
MOVD ((offset)+(4*8))(R3), F28 \
MOVD ((offset)+(5*8))(R3), F29 \
MOVD ((offset)+(6*8))(R3), F30 \
MOVD ((offset)+(7*8))(R3), F31
golang-github-ebitengine-purego-0.10.1/callback_test.go 0000664 0000000 0000000 00000032110 15207302613 0023044 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
//go:build darwin || (linux && (386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || s390x))
package purego_test
import (
"fmt"
"os"
"path/filepath"
"runtime"
"testing"
"unsafe"
"github.com/ebitengine/purego"
)
// TestCallGoFromSharedLib is a test that checks for stack corruption on arm64
// when C calls Go code from a non-Go thread in a dynamically loaded share library.
func TestCallGoFromSharedLib(t *testing.T) {
libFileName := filepath.Join(t.TempDir(), "libcbtest.so")
t.Logf("Build %v", libFileName)
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallback func(p uintptr, s string) int
purego.RegisterLibFunc(&callCallback, lib, "callCallback")
goFunc := func(cstr *byte, n int) int {
s := string(unsafe.Slice(cstr, n))
t.Logf("FROM Go: %s\n", s)
return 1
}
const want = 10101
cb := purego.NewCallback(goFunc)
for i := 0; i < 10; i++ {
got := callCallback(cb, "a test string")
if got != want {
t.Fatalf("%d: callCallback() got %v want %v", i, got, want)
}
}
}
func TestNewCallbackFloat64(t *testing.T) {
// This tests the maximum number of arguments a function to NewCallback can take
const (
expectCbTotal = -3
expectedCbTotalF = float64(36)
)
var cbTotal int
var cbTotalF float64
imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int,
f1, f2, f3, f4, f5, f6, f7, f8 float64,
) {
cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9
cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8
})
var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int,
f1, f2, f3, f4, f5, f6, f7, f8 float64)
purego.RegisterFunc(&fn, imp)
fn(1, 2, -3, 4, -5, 6, -7, 8, -9,
1, 2, 3, 4, 5, 6, 7, 8)
if cbTotal != expectCbTotal {
t.Errorf("cbTotal not correct got %d but wanted %d", cbTotal, expectCbTotal)
}
if cbTotalF != expectedCbTotalF {
t.Errorf("cbTotalF not correct got %f but wanted %f", cbTotalF, expectedCbTotalF)
}
}
func TestNewCallbackFloat64AndIntMix(t *testing.T) {
// This tests interleaving float and integer arguments to NewCallback
const (
expectCbTotal = 54.75
)
var cbTotal float64
imp := purego.NewCallback(func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int) {
cbTotal = a1 + a2 + float64(a3) + float64(a4) + float64(a5) + a6 + a7 + a8 + float64(a9)
})
var fn func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int)
purego.RegisterFunc(&fn, imp)
fn(1.25, 3.25, 4, 5, 6, 7.5, 8.25, 9.5, 10)
if cbTotal != expectCbTotal {
t.Errorf("cbTotal not correct got %f but wanted %f", cbTotal, expectCbTotal)
}
}
func TestNewCallbackFloat32(t *testing.T) {
// This tests the maximum number of float32 arguments a function to NewCallback can take
const (
expectCbTotal = 6
expectedCbTotalF = float32(45)
)
var cbTotal int
var cbTotalF float32
imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8 int,
f1, f2, f3, f4, f5, f6, f7, f8, f9 float32,
) {
cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8
cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9
})
var fn func(a1, a2, a3, a4, a5, a6, a7, a8 int,
f1, f2, f3, f4, f5, f6, f7, f8, f9 float32)
purego.RegisterFunc(&fn, imp)
fn(1, 2, -3, 4, -5, 6, -7, 8,
1, 2, 3, 4, 5, 6, 7, 8, 9)
if cbTotal != expectCbTotal {
t.Errorf("cbTotal not correct got %d but wanted %d", cbTotal, expectCbTotal)
}
if cbTotalF != expectedCbTotalF {
t.Errorf("cbTotalF not correct got %f but wanted %f", cbTotalF, expectedCbTotalF)
}
}
func TestNewCallbackFloat32AndFloat64(t *testing.T) {
if runtime.GOARCH == "s390x" {
// S390X has only 4 float registers (F0,F2,F4,F6), so 15 floats requires
// 11 stack slots, but only 10 are available (maxArgs - numIntRegs = 15 - 5)
t.Skip("Test requires too many stack arguments for s390x")
}
// This tests that calling a function with a mix of float32 and float64 arguments works
const (
expectedCbTotalF32 = float32(72)
expectedCbTotalF64 = float64(48)
)
var cbTotalF32 float32
var cbTotalF64 float64
imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32) {
cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9 + f13 + f14 + f15
cbTotalF64 = f4 + f5 + f6 + f10 + f11 + f12
})
var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32)
purego.RegisterFunc(&fn, imp)
fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
if cbTotalF32 != expectedCbTotalF32 {
t.Errorf("cbTotalF32 not correct got %f but wanted %f", cbTotalF32, expectedCbTotalF32)
}
if cbTotalF64 != expectedCbTotalF64 {
t.Errorf("cbTotalF64 not correct got %f but wanted %f", cbTotalF64, expectedCbTotalF64)
}
}
func ExampleNewCallback() {
cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int {
fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15
})
var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int
purego.RegisterFunc(&fn, cb)
ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
fmt.Println(ret)
// Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// 120
}
func ExampleNewCallback_cdecl() {
fn := func(_ purego.CDecl, a int) {
fmt.Println(a)
}
cb := purego.NewCallback(fn)
purego.SyscallN(cb, 83)
// Output: 83
}
func TestCallbackInt32Packing(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallback12Int32 func(cb uintptr) int32
purego.RegisterLibFunc(&callCallback12Int32, lib, "callCallback12Int32")
// Go callback that sums the 12 int32 arguments (prime numbers: 2,3,5,7,11,13,17,19,23,29,31,37)
goFunc := func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 int32) int32 {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12
}
cb := purego.NewCallback(goFunc)
got := callCallback12Int32(cb)
want := int32(2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37) // 197
if got != want {
t.Errorf("callCallback12Int32() = %d, want %d", got, want)
}
}
func TestCallbackMixedStackPacking(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallbackMixedStack func(cb uintptr) int64
purego.RegisterLibFunc(&callCallbackMixedStack, lib, "callCallbackMixedStack")
// Go callback: 8 int64s in regs, then int32(100), int64(200), int32(300) on stack
goFunc := func(a1, a2, a3, a4, a5, a6, a7, a8 int64, s1 int32, s2 int64, s3 int32) int64 {
// Return sum to verify all args received correctly
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + int64(s1) + s2 + int64(s3)
}
cb := purego.NewCallback(goFunc)
got := callCallbackMixedStack(cb)
want := int64(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 100 + 200 + 300) // 636
if got != want {
t.Errorf("callCallbackMixedStack() = %d, want %d", got, want)
}
}
func TestCallbackSmallTypesPacking(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallbackSmallTypes func(cb uintptr) int64
purego.RegisterLibFunc(&callCallbackSmallTypes, lib, "callCallbackSmallTypes")
// Values: 1,2,3,4,5,6,7,8 (regs), true, -42, 200, -1000, 50000, 123456 (stack)
var gotBool bool
var gotI8 int8
var gotU8 uint8
var gotI16 int16
var gotU16 uint16
var gotI32 int32
goFunc := func(a1, a2, a3, a4, a5, a6, a7, a8 int64,
b bool, i8 int8, u8 uint8, i16 int16, u16 uint16, i32 int32) int64 {
gotBool = b
gotI8 = i8
gotU8 = u8
gotI16 = i16
gotU16 = u16
gotI32 = i32
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8
}
cb := purego.NewCallback(goFunc)
got := callCallbackSmallTypes(cb)
// Check register args sum
want := int64(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8) // 36
if got != want {
t.Errorf("register args sum = %d, want %d", got, want)
}
// Check stack args
if gotBool != true {
t.Errorf("bool = %v, want true", gotBool)
}
if gotI8 != -42 {
t.Errorf("int8 = %d, want -42", gotI8)
}
if gotU8 != 200 {
t.Errorf("uint8 = %d, want 200", gotU8)
}
if gotI16 != -1000 {
t.Errorf("int16 = %d, want -1000", gotI16)
}
if gotU16 != 50000 {
t.Errorf("uint16 = %d, want 50000", gotU16)
}
if gotI32 != 123456 {
t.Errorf("int32 = %d, want 123456", gotI32)
}
}
func TestCallback10Int32Packing(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallback10Int32 func(cb uintptr) int32
purego.RegisterLibFunc(&callCallback10Int32, lib, "callCallback10Int32")
goFunc := func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 int32) int32 {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10
}
cb := purego.NewCallback(goFunc)
got := callCallback10Int32(cb)
want := int32(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) // 55
if got != want {
t.Errorf("callCallback10Int32() = %d, want %d", got, want)
}
}
func TestCallbackFloat64StackPacking(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallback10Float64 func(cb uintptr) int64
purego.RegisterLibFunc(&callCallback10Float64, lib, "callCallback10Float64")
// 10 float64s: 8 in registers, 2 on stack
// Return int64 since callbacks don't support float returns
goFunc := func(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10 float64) int64 {
sum := f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10
return int64(sum * 10) // 60.0 * 10 = 600
}
cb := purego.NewCallback(goFunc)
got := callCallback10Float64(cb)
want := int64(600)
if got != want {
t.Errorf("callCallback10Float64() = %d, want %d", got, want)
}
}
func TestCallbackFloat32StackPacking(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("callback tight packing only applies to darwin/arm64")
}
libFileName := filepath.Join(t.TempDir(), "libcbtest_packing.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
var callCallback12Float32 func(cb uintptr) int64
purego.RegisterLibFunc(&callCallback12Float32, lib, "callCallback12Float32")
// 12 float32s: 8 in registers, 4 on stack
// Return int64 since callbacks don't support float returns
goFunc := func(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12 float32) int64 {
sum := f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
return int64(sum) // 78
}
cb := purego.NewCallback(goFunc)
got := callCallback12Float32(cb)
want := int64(78)
if got != want {
t.Errorf("callCallback12Float32() = %d, want %d", got, want)
}
}
golang-github-ebitengine-purego-0.10.1/cgo.go 0000664 0000000 0000000 00000001426 15207302613 0021027 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build cgo && (darwin || freebsd || linux || netbsd)
package purego
// if CGO_ENABLED=1 import the Cgo runtime to ensure that it is set up properly.
// This is required since some frameworks need TLS setup the C way which Go doesn't do.
// We currently don't support ios in fakecgo mode so force Cgo or fail.
// Even if CGO_ENABLED=1 the Cgo runtime is not imported unless `import "C"` is used,
// which will import this package automatically. Normally this isn't an issue since it
// usually isn't possible to call into C without using that import. However, with purego
// it is since we don't use `import "C"`!
import (
_ "runtime/cgo"
_ "github.com/ebitengine/purego/internal/cgo"
)
golang-github-ebitengine-purego-0.10.1/dlerror.go 0000664 0000000 0000000 00000000632 15207302613 0021726 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd
package purego
// Dlerror represents an error value returned from Dlopen, Dlsym, or Dlclose.
//
// This type is not available on Windows as there is no counterpart to it on Windows.
type Dlerror struct {
s string
}
func (e Dlerror) Error() string {
return e.s
}
golang-github-ebitengine-purego-0.10.1/dlfcn.go 0000664 0000000 0000000 00000006711 15207302613 0021347 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build (darwin || freebsd || linux || netbsd) && !android && !faketime
package purego
import (
"unsafe"
)
// Unix Specification for dlfcn.h: https://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html
var (
fnDlopen func(path string, mode int) uintptr
fnDlsym func(handle uintptr, name string) uintptr
fnDlerror func() string
fnDlclose func(handle uintptr) bool
)
func init() {
RegisterFunc(&fnDlopen, dlopenABI0)
RegisterFunc(&fnDlsym, dlsymABI0)
RegisterFunc(&fnDlerror, dlerrorABI0)
RegisterFunc(&fnDlclose, dlcloseABI0)
}
// Dlopen examines the dynamic library or bundle file specified by path. If the file is compatible
// with the current process and has not already been loaded into the
// current process, it is loaded and linked. After being linked, if it contains
// any initializer functions, they are called, before Dlopen
// returns. It returns a handle that can be used with Dlsym and Dlclose.
// A second call to Dlopen with the same path will return the same handle, but the internal
// reference count for the handle will be incremented. Therefore, all
// Dlopen calls should be balanced with a Dlclose call.
//
// This function is not available on Windows.
// Use [golang.org/x/sys/windows.LoadLibrary], [golang.org/x/sys/windows.LoadLibraryEx],
// [golang.org/x/sys/windows.NewLazyDLL], or [golang.org/x/sys/windows.NewLazySystemDLL] for Windows instead.
func Dlopen(path string, mode int) (uintptr, error) {
u := fnDlopen(path, mode)
if u == 0 {
return 0, Dlerror{fnDlerror()}
}
return u, nil
}
// Dlsym takes a "handle" of a dynamic library returned by Dlopen and the symbol name.
// It returns the address where that symbol is loaded into memory. If the symbol is not found,
// in the specified library or any of the libraries that were automatically loaded by Dlopen
// when that library was loaded, Dlsym returns zero.
//
// This function is not available on Windows.
// Use [golang.org/x/sys/windows.GetProcAddress] for Windows instead.
func Dlsym(handle uintptr, name string) (uintptr, error) {
u := fnDlsym(handle, name)
if u == 0 {
return 0, Dlerror{fnDlerror()}
}
return u, nil
}
// Dlclose decrements the reference count on the dynamic library handle.
// If the reference count drops to zero and no other loaded libraries
// use symbols in it, then the dynamic library is unloaded.
//
// This function is not available on Windows.
// Use [golang.org/x/sys/windows.FreeLibrary] for Windows instead.
func Dlclose(handle uintptr) error {
if fnDlclose(handle) {
return Dlerror{fnDlerror()}
}
return nil
}
func loadSymbol(handle uintptr, name string) (uintptr, error) {
return Dlsym(handle, name)
}
// these functions exist in dlfcn_stubs.s and are calling C functions linked to in dlfcn_GOOS.go
// the indirection is necessary because a function is actually a pointer to the pointer to the code.
// sadly, I do not know of anyway to remove the assembly stubs entirely because //go:linkname doesn't
// appear to work if you link directly to the C function on darwin arm64.
//go:linkname dlopen dlopen
var dlopen uint8
var dlopenABI0 = uintptr(unsafe.Pointer(&dlopen))
//go:linkname dlsym dlsym
var dlsym uint8
var dlsymABI0 = uintptr(unsafe.Pointer(&dlsym))
//go:linkname dlclose dlclose
var dlclose uint8
var dlcloseABI0 = uintptr(unsafe.Pointer(&dlclose))
//go:linkname dlerror dlerror
var dlerror uint8
var dlerrorABI0 = uintptr(unsafe.Pointer(&dlerror))
golang-github-ebitengine-purego-0.10.1/dlfcn_android.go 0000664 0000000 0000000 00000001566 15207302613 0023052 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package purego
import "github.com/ebitengine/purego/internal/cgo"
// Source for constants: https://android.googlesource.com/platform/bionic/+/refs/heads/main/libc/include/dlfcn.h
const (
is64bit = 1 << (^uintptr(0) >> 63) / 2
is32bit = 1 - is64bit
RTLD_DEFAULT = is32bit * 0xffffffff
RTLD_LAZY = 0x00000001
RTLD_NOW = is64bit * 0x00000002
RTLD_LOCAL = 0x00000000
RTLD_GLOBAL = is64bit*0x00100 | is32bit*0x00000002
)
func Dlopen(path string, mode int) (uintptr, error) {
return cgo.Dlopen(path, mode)
}
func Dlsym(handle uintptr, name string) (uintptr, error) {
return cgo.Dlsym(handle, name)
}
func Dlclose(handle uintptr) error {
return cgo.Dlclose(handle)
}
func loadSymbol(handle uintptr, name string) (uintptr, error) {
return Dlsym(handle, name)
}
golang-github-ebitengine-purego-0.10.1/dlfcn_darwin.go 0000664 0000000 0000000 00000002051 15207302613 0022704 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
package purego
// Source for constants: https://opensource.apple.com/source/dyld/dyld-360.14/include/dlfcn.h.auto.html
const (
RTLD_DEFAULT = 1<<64 - 2 // Pseudo-handle for dlsym so search for any loaded symbol
RTLD_LAZY = 0x1 // Relocations are performed at an implementation-dependent time.
RTLD_NOW = 0x2 // Relocations are performed when the object is loaded.
RTLD_LOCAL = 0x4 // All symbols are not made available for relocation processing by other modules.
RTLD_GLOBAL = 0x8 // All symbols are available for relocation processing of other modules.
)
//go:cgo_import_dynamic purego_dlopen dlopen "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_dlsym dlsym "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_dlerror dlerror "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_dlclose dlclose "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_error __error "/usr/lib/libSystem.B.dylib"
golang-github-ebitengine-purego-0.10.1/dlfcn_freebsd.go 0000664 0000000 0000000 00000001433 15207302613 0023035 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
package purego
// Constants as defined in https://github.com/freebsd/freebsd-src/blob/main/include/dlfcn.h
const (
intSize = 32 << (^uint(0) >> 63) // 32 or 64
RTLD_DEFAULT = 1<> 63) // 32 or 64
RTLD_DEFAULT = 1<
// @property (readwrite) bar int
// @end
class, err := objc.RegisterClass(
"BarObject",
objc.GetClass("NSObject"),
[]*objc.Protocol{
objc.GetProtocol("NSDelegateWindow"),
},
[]objc.FieldDef{
{
Name: "bar",
Type: reflect.TypeOf(int(0)),
Attribute: objc.ReadWrite,
},
},
[]objc.MethodDef{
{
Cmd: sel_init,
Fn: BarInit,
},
},
)
if err != nil {
panic(err)
}
object := objc.ID(class).Send(sel_new)
object.Send(sel_setBar, 123)
bar := int(object.Send(sel_bar))
fmt.Println(bar)
// Output: 123
}
golang-github-ebitengine-purego-0.10.1/examples/protocol-dumper/ 0000775 0000000 0000000 00000000000 15207302613 0024676 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/examples/protocol-dumper/main_darwin.go 0000664 0000000 0000000 00000011414 15207302613 0027516 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package main
// #cgo CFLAGS: -x objective-c
// #cgo LDFLAGS: -framework AppKit
//
// #import
//
// __attribute__((used))
// static void __force_protocol_load() {
// id o = NULL;
// o = @protocol(NSAccessibility);
// o = @protocol(NSApplicationDelegate);
// }
import "C"
import (
"fmt"
"io"
"os"
"strconv"
"strings"
"text/template"
"github.com/ebitengine/purego/objc"
)
var protocols = []string{
"NSAccessibility",
"NSApplicationDelegate",
}
type ProtocolImpl struct {
Name string
RequiredInstanceMethods []objc.MethodDescription
RequiredClassMethods []objc.MethodDescription
OptionalInstanceMethods []objc.MethodDescription
OptionalClassMethods []objc.MethodDescription
AdoptedProtocols []*objc.Protocol
RequiredInstanceProperties []objc.Property
RequiredClassProperties []objc.Property
OptionalInstanceProperties []objc.Property
OptionalClassProperties []objc.Property
}
func readProtocols(names []string) (imps []ProtocolImpl, err error) {
for _, name := range names {
p := objc.GetProtocol(name)
if p == nil {
return nil, fmt.Errorf("protocol '%s' does not exist", name)
}
imp := ProtocolImpl{}
imp.Name = name
imp.RequiredInstanceMethods = p.CopyMethodDescriptionList(true, true)
imp.RequiredClassMethods = p.CopyMethodDescriptionList(true, false)
imp.OptionalInstanceMethods = p.CopyMethodDescriptionList(false, true)
imp.OptionalClassMethods = p.CopyMethodDescriptionList(false, false)
imp.AdoptedProtocols = p.CopyProtocolList()
imp.RequiredInstanceProperties = p.CopyPropertyList(true, true)
imp.RequiredClassProperties = p.CopyPropertyList(true, false)
imp.OptionalInstanceProperties = p.CopyPropertyList(false, true)
imp.OptionalClassProperties = p.CopyPropertyList(false, false)
imps = append(imps, imp)
}
return imps, nil
}
const templ = `// Code generated by protocol-dumper; DO NOT EDIT.
package main
import (
"log"
"github.com/ebitengine/purego/objc"
)
func init() {
var p *objc.Protocol
{{- range . }}
{{- $protocolName := .Name }}
if p = objc.AllocateProtocol("{{$protocolName}}"); p != nil {
{{- range .RequiredInstanceMethods }}
p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", true, true)
{{- end }}
{{- range .RequiredClassMethods }}
p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", true, false)
{{- end }}
{{- range .OptionalInstanceMethods }}
p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", false, true)
{{- end }}
{{- range .OptionalClassMethods }}
p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", false, false)
{{- end }}
var adoptedProtocol *objc.Protocol
{{- range .AdoptedProtocols }}
adoptedProtocol = objc.GetProtocol("{{ .Name }}")
if adoptedProtocol == nil {
log.Fatalln("protocol '{{ .Name }}' does not exist")
}
p.AddProtocol(adoptedProtocol)
{{- end }}
{{- range .RequiredInstanceProperties }}
p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, true, true)
{{- end }}
{{- range .RequiredClassProperties }}
p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, true, false)
{{- end }}
{{- range .OptionalInstanceProperties }}
p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, false, true)
{{- end }}
{{- range .OptionalClassProperties }}
p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, false, false)
{{- end }}
p.Register()
} // Finished protocol: {{$protocolName}}
{{- end }}
}
`
func printProtocols(impls []ProtocolImpl, w io.Writer) error {
tmpl, err := template.New("protocol.tmpl").Funcs(template.FuncMap{
"attributeToStructString": attributeToStructString,
}).Parse(templ)
if err != nil {
return err
}
err = tmpl.Execute(w, impls)
if err != nil {
return err
}
return nil
}
func attributeToStructString(p objc.Property) string {
attribs := strings.Split(p.Attributes(), ",")
var b strings.Builder
b.WriteString("[]objc.PropertyAttribute{")
for i, attrib := range attribs {
b.WriteString(fmt.Sprintf(`{Name: &[]byte("%s\x00")[0], Value: &[]byte(%s)[0]}`, string(attrib[0]), strconv.Quote(attrib[1:]+"\x00")))
if i != len(attribs)-1 {
b.WriteString(", ")
}
}
b.WriteString("}")
return b.String()
}
// This program prints out the Go code to generate the OBJC protocols list.
// To use it add the @protocol(name) to the C import section and then add it to the protocols list.
// You'll want to run it as amd64 and arm64 since the types are slightly different for each architecture.
func main() {
var imps []ProtocolImpl
var err error
if imps, err = readProtocols(protocols); err != nil {
panic(err)
}
if err = printProtocols(imps, os.Stdout); err != nil {
panic(err)
}
}
golang-github-ebitengine-purego-0.10.1/examples/window/ 0000775 0000000 0000000 00000000000 15207302613 0023052 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/examples/window/main_darwin.go 0000664 0000000 0000000 00000003125 15207302613 0025672 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package main
import (
"runtime"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/objc"
)
const (
NSApplicationActivationPolicyRegular = 0
NSWindowStyleMaskTitled = 1 << 0
NSBackingStoreBuffered = 2
)
type NSPoint struct {
X, Y float64
}
type NSSize struct {
Width, Height float64
}
type NSRect struct {
Origin NSPoint
Size NSSize
}
func init() {
runtime.LockOSThread()
}
func main() {
if _, err := purego.Dlopen("/System/Library/Frameworks/Cocoa.framework/Cocoa", purego.RTLD_GLOBAL|purego.RTLD_LAZY); err != nil {
panic(err)
}
nsApp := objc.ID(objc.GetClass("NSApplication")).Send(objc.RegisterName("sharedApplication"))
nsApp.Send(objc.RegisterName("setActivationPolicy:"), NSApplicationActivationPolicyRegular)
wnd := objc.ID(objc.GetClass("NSWindow")).Send(objc.RegisterName("alloc"))
wnd = wnd.Send(objc.RegisterName("initWithContentRect:styleMask:backing:defer:"),
NSMakeRect(0, 0, 320, 240),
NSWindowStyleMaskTitled,
NSBackingStoreBuffered,
false,
)
title := objc.ID(objc.GetClass("NSString")).Send(objc.RegisterName("stringWithUTF8String:"), "My Title")
wnd.Send(objc.RegisterName("setTitle:"), title)
wnd.Send(objc.RegisterName("makeKeyAndOrderFront:"), objc.ID(0))
wnd.Send(objc.RegisterName("center"))
nsApp.Send(objc.RegisterName("activateIgnoringOtherApps:"), true)
nsApp.Send(objc.RegisterName("run"))
}
func NSMakeRect(x, y, width, height float64) NSRect {
return NSRect{Origin: NSPoint{x, y}, Size: NSSize{width, height}}
}
golang-github-ebitengine-purego-0.10.1/examples/window/main_windows.go 0000664 0000000 0000000 00000007477 15207302613 0026116 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package main
import (
"runtime"
"syscall"
"unsafe"
"github.com/ebitengine/purego"
)
const (
WS_OVERLAPPEDWINDOW = 0x00000000 | 0x00C00000 | 0x00080000 | 0x00040000 | 0x00020000 | 0x00010000
CW_USEDEFAULT = ^0x7fffffff
SW_SHOW = 5
WM_DESTROY = 2
)
type (
ATOM uint16
HANDLE uintptr
HINSTANCE HANDLE
HICON HANDLE
HCURSOR HANDLE
HBRUSH HANDLE
HWND HANDLE
HMENU HANDLE
)
type WNDCLASSEX struct {
Size uint32
Style uint32
WndProc uintptr
ClsExtra int32
WndExtra int32
Instance HINSTANCE
Icon HICON
Cursor HCURSOR
Background HBRUSH
MenuName *uint16
ClassName *uint16
IconSm HICON
}
type RECT struct {
Left, Top, Right, Bottom int32
}
type POINT struct {
X, Y int32
}
type MSG struct {
Hwnd HWND
Message uint32
WParam uintptr
LParam uintptr
Time uint32
Pt POINT
}
var (
GetModuleHandle func(modulename *uint16) HINSTANCE
RegisterClassEx func(w *WNDCLASSEX) ATOM
CreateWindowEx func(exStyle uint, className, windowName *uint16,
style uint, x, y, width, height int, parent HWND, menu HMENU,
instance HINSTANCE, param unsafe.Pointer) HWND
AdjustWindowRect func(rect *RECT, style uint, menu bool) bool
ShowWindow func(hwnd HWND, cmdshow int) bool
GetMessage func(msg *MSG, hwnd HWND, msgFilterMin, msgFilterMax uint32) int
TranslateMessage func(msg *MSG) bool
DispatchMessage func(msg *MSG) uintptr
DefWindowProc func(hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr
PostQuitMessage func(exitCode int)
)
func init() {
// Use [syscall.NewLazyDLL] here to avoid external dependencies (#270).
// For actual use cases, [golang.org/x/sys/windows.NewLazySystemDLL] is recommended.
kernel32 := syscall.NewLazyDLL("kernel32.dll").Handle()
purego.RegisterLibFunc(&GetModuleHandle, kernel32, "GetModuleHandleW")
// Use [syscall.NewLazyDLL] here to avoid external dependencies (#270).
// For actual use cases, [golang.org/x/sys/windows.NewLazySystemDLL] is recommended.
user32 := syscall.NewLazyDLL("user32.dll").Handle()
purego.RegisterLibFunc(&RegisterClassEx, user32, "RegisterClassExW")
purego.RegisterLibFunc(&CreateWindowEx, user32, "CreateWindowExW")
purego.RegisterLibFunc(&AdjustWindowRect, user32, "AdjustWindowRect")
purego.RegisterLibFunc(&ShowWindow, user32, "ShowWindow")
purego.RegisterLibFunc(&GetMessage, user32, "GetMessageW")
purego.RegisterLibFunc(&TranslateMessage, user32, "TranslateMessage")
purego.RegisterLibFunc(&DispatchMessage, user32, "DispatchMessageW")
purego.RegisterLibFunc(&DefWindowProc, user32, "DefWindowProcW")
purego.RegisterLibFunc(&PostQuitMessage, user32, "PostQuitMessage")
runtime.LockOSThread()
}
func main() {
className, err := syscall.UTF16PtrFromString("Sample Window Class")
if err != nil {
panic(err)
}
inst := GetModuleHandle(className)
wc := WNDCLASSEX{
Size: uint32(unsafe.Sizeof(WNDCLASSEX{})),
WndProc: syscall.NewCallback(wndProc),
Instance: inst,
ClassName: className,
}
RegisterClassEx(&wc)
wr := RECT{
Left: 0,
Top: 0,
Right: 320,
Bottom: 240,
}
title, err := syscall.UTF16PtrFromString("My Title")
if err != nil {
panic(err)
}
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, false)
hwnd := CreateWindowEx(
0, className,
title,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, int(wr.Right-wr.Left), int(wr.Bottom-wr.Top),
0, 0, inst, nil,
)
if hwnd == 0 {
panic(syscall.GetLastError())
}
ShowWindow(hwnd, SW_SHOW)
var msg MSG
for GetMessage(&msg, 0, 0, 0) != 0 {
TranslateMessage(&msg)
DispatchMessage(&msg)
}
}
func wndProc(hwnd HWND, msg uint32, wparam, lparam uintptr) uintptr {
switch msg {
case WM_DESTROY:
PostQuitMessage(0)
}
return DefWindowProc(hwnd, msg, wparam, lparam)
}
golang-github-ebitengine-purego-0.10.1/func.go 0000664 0000000 0000000 00000047613 15207302613 0021222 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd || windows
package purego
import (
"fmt"
"math"
"reflect"
"runtime"
"unsafe"
"github.com/ebitengine/purego/internal/strings"
"github.com/ebitengine/purego/internal/xreflect"
)
const (
align8ByteMask = 7 // Mask for 8-byte alignment: (val + 7) &^ 7
align8ByteSize = 8 // 8-byte alignment boundary
)
// RegisterLibFunc is a wrapper around RegisterFunc that uses the C function returned from Dlsym(handle, name).
// It panics if it can't find the name symbol.
func RegisterLibFunc(fptr any, handle uintptr, name string) {
sym, err := loadSymbol(handle, name)
if err != nil {
panic(err)
}
RegisterFunc(fptr, sym)
}
// RegisterFunc takes a pointer to a Go function representing the calling convention of the C function.
// fptr will be set to a function that when called will call the C function given by cfn with the
// parameters passed in the correct registers and stack.
//
// A panic is produced if the type is not a function pointer or if the function returns more than 1 value.
//
// These conversions describe how a Go type in the fptr will be used to call
// the C function. It is important to note that there is no way to verify that fptr
// matches the C function. This also holds true for struct types where the padding
// needs to be ensured to match that of C; RegisterFunc does not verify this.
//
// # Type Conversions (Go <=> C)
//
// string <=> char*
// bool <=> _Bool
// uintptr <=> uintptr_t
// uint <=> uint32_t or uint64_t
// uint8 <=> uint8_t
// uint16 <=> uint16_t
// uint32 <=> uint32_t
// uint64 <=> uint64_t
// int <=> int32_t or int64_t
// int8 <=> int8_t
// int16 <=> int16_t
// int32 <=> int32_t
// int64 <=> int64_t
// float32 <=> float
// float64 <=> double
// struct <=> struct (darwin amd64/arm64, linux amd64/arm64)
// func <=> C function
// unsafe.Pointer, *T <=> void*
// []T => void*
//
// There is a special case when the last argument of fptr is a variadic interface (or []interface}
// it will be expanded into a call to the C function as if it had the arguments in that slice.
// This means that using arg ...any is like a cast to the function with the arguments inside arg.
// This is not the same as C variadic.
//
// # Memory
//
// In general it is not possible for purego to guarantee the lifetimes of objects returned or received from
// calling functions using RegisterFunc. For arguments to a C function it is important that the C function doesn't
// hold onto a reference to Go memory. This is the same as the [Cgo rules].
//
// However, there are some special cases. When passing a string as an argument if the string does not end in a null
// terminated byte (\x00) then the string will be copied into memory maintained by purego. The memory is only valid for
// that specific call. Therefore, if the C code keeps a reference to that string it may become invalid at some
// undefined time. However, if the string does already contain a null-terminated byte then no copy is done.
// It is then the responsibility of the caller to ensure the string stays alive as long as it's needed in C memory.
// This can be done using runtime.KeepAlive or allocating the string in C memory using malloc. When a C function
// returns a null-terminated pointer to char a Go string can be used. Purego will allocate a new string in Go memory
// and copy the data over. This string will be garbage collected whenever Go decides it's no longer referenced.
// This C created string will not be freed by purego. If the pointer to char is not null-terminated or must continue
// to point to C memory (because it's a buffer for example) then use a pointer to byte and then convert that to a slice
// using unsafe.Slice. Doing this means that it becomes the responsibility of the caller to care about the lifetime
// of the pointer
//
// # Structs
//
// Purego can handle the most common structs that have fields of builtin types like int8, uint16, float32, etc. However,
// it does not support aligning fields properly. It is therefore the responsibility of the caller to ensure
// that all padding is added to the Go struct to match the C one. See `BoolStructFn` in struct_test.go for an example.
//
// On Darwin ARM64, purego handles proper alignment of struct arguments when passing them on the stack,
// following the C ABI's byte-level packing rules.
//
// # Example
//
// All functions below call this C function:
//
// char *foo(char *str);
//
// // Let purego convert types
// var foo func(s string) string
// goString := foo("copied")
// // Go will garbage collect this string
//
// // Manually, handle allocations
// var foo2 func(b string) *byte
// mustFree := foo2("not copied\x00")
// defer free(mustFree)
//
// [Cgo rules]: https://pkg.go.dev/cmd/cgo#hdr-Go_references_to_C
func RegisterFunc(fptr any, cfn uintptr) {
const is32bit = unsafe.Sizeof(uintptr(0)) == 4
fn := reflect.ValueOf(fptr).Elem()
ty := fn.Type()
if ty.Kind() != reflect.Func {
panic("purego: fptr must be a function pointer")
}
if ty.NumOut() > 1 {
panic("purego: function can only return zero or one values")
}
if cfn == 0 {
panic("purego: cfn is nil")
}
if ty.NumOut() == 1 && (ty.Out(0).Kind() == reflect.Float32 || ty.Out(0).Kind() == reflect.Float64) &&
runtime.GOARCH != "arm" && runtime.GOARCH != "arm64" && runtime.GOARCH != "386" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "riscv64" && runtime.GOARCH != "s390x" {
panic("purego: float returns are not supported")
}
{
// this code checks how many registers and stack this function will use
// to avoid crashing with too many arguments
var ints int
var floats int
var stack int
for i := 0; i < ty.NumIn(); i++ {
arg := ty.In(i)
switch arg.Kind() {
case reflect.Func:
// This only does preliminary testing to ensure the CDecl argument
// is the first argument. Full testing is done when the callback is actually
// created in NewCallback.
for j := 0; j < arg.NumIn(); j++ {
in := arg.In(j)
if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
continue
}
if j != 0 {
panic("purego: CDecl must be the first argument")
}
}
case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer,
reflect.Slice, reflect.Bool:
if ints < numOfIntegerRegisters() {
ints++
} else {
stack++
}
case reflect.Float32, reflect.Float64:
if floats < numOfFloatRegisters() {
floats++
} else {
stack++
}
case reflect.Struct:
ensureStructSupportedForRegisterFunc()
if arg.Size() == 0 {
continue
}
addInt := func(u uintptr) {
ints++
}
addFloat := func(u uintptr) {
floats++
}
addStack := func(u uintptr) {
stack++
}
_ = addStruct(reflect.New(arg).Elem(), &ints, &floats, &stack, addInt, addFloat, addStack, nil)
default:
panic("purego: unsupported kind " + arg.Kind().String())
}
}
if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct {
ensureStructSupportedForRegisterFunc()
outType := ty.Out(0)
checkStructFieldsSupported(outType)
if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize {
// on amd64 if struct is bigger than 16 bytes allocate the return struct
// and pass it in as a hidden first argument.
ints++
}
}
sizeOfStack := maxArgs - numOfIntegerRegisters()
// On Darwin ARM64, use byte-based validation since arguments pack efficiently.
// See https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
stackBytes := estimateStackBytes(ty)
maxStackBytes := sizeOfStack * 8
if stackBytes > maxStackBytes {
panic("purego: too many stack arguments")
}
} else {
if stack > sizeOfStack {
panic("purego: too many stack arguments")
}
}
}
v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) {
var sysargs [maxArgs]uintptr
// Use maxArgs instead of numOfFloatRegisters() to keep this code path allocation-free,
// since numOfFloatRegisters() is a function call, not a constant.
// maxArgs is always greater than or equal to numOfFloatRegisters() so this is safe.
var floats [maxArgs]uintptr
var numInts int
var numFloats int
var numStack int
var addStack, addInt, addFloat func(x uintptr)
if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {
// Windows arm64 uses the same calling convention as macOS and Linux
addStack = func(x uintptr) {
sysargs[numOfIntegerRegisters()+numStack] = x
numStack++
}
addInt = func(x uintptr) {
if numInts >= numOfIntegerRegisters() {
addStack(x)
} else {
sysargs[numInts] = x
numInts++
}
}
addFloat = func(x uintptr) {
if numFloats < numOfFloatRegisters() {
floats[numFloats] = x
numFloats++
} else {
addStack(x)
}
}
} else {
// On Windows amd64 the arguments are passed in the numbered registered.
// So the first int is in the first integer register and the first float
// is in the second floating register if there is already a first int.
// This is in contrast to how macOS and Linux pass arguments which
// tries to use as many registers as possible in the calling convention.
addStack = func(x uintptr) {
sysargs[numStack] = x
numStack++
}
addInt = addStack
addFloat = addStack
}
var keepAlive []any
defer func() {
runtime.KeepAlive(keepAlive)
runtime.KeepAlive(args)
}()
var arm64_r8 uintptr
if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct {
outType := ty.Out(0)
if (runtime.GOARCH == "amd64" || runtime.GOARCH == "loong64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "s390x") && outType.Size() > maxRegAllocStructSize {
val := reflect.New(outType)
keepAlive = append(keepAlive, val)
addInt(val.Pointer())
} else if runtime.GOARCH == "arm64" && outType.Size() > maxRegAllocStructSize {
isAllFloats, numFields := isAllSameFloat(outType)
if !isAllFloats || numFields > 4 {
val := reflect.New(outType)
keepAlive = append(keepAlive, val)
arm64_r8 = val.Pointer()
}
}
}
for i, v := range args {
if variadic, ok := xreflect.TypeAssert[[]any](args[i]); ok {
if i != len(args)-1 {
panic("purego: can only expand last parameter")
}
for _, x := range variadic {
keepAlive = addValue(reflect.ValueOf(x), keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
}
continue
}
// Check if we need to start Darwin ARM64 C-style stack packing
if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && shouldBundleStackArgs(v, numInts, numFloats) {
// Collect and separate remaining args into register vs stack
stackArgs, newKeepAlive := collectStackArgs(args, i, numInts, numFloats,
keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
keepAlive = newKeepAlive
// Bundle stack arguments with C-style packing
bundleStackArgs(stackArgs, addStack)
break
}
keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
}
syscall := &syscall15Args{}
if runtime.GOARCH == "loong64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "s390x" {
syscall.Set(cfn, sysargs[:], floats[:], 0)
runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall))
} else if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {
// Use the normal arm64 calling convention even on Windows
syscall.Set(cfn, sysargs[:], floats[:], arm64_r8)
runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall))
} else {
// This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
syscall.a1, syscall.a2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4],
sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
sysargs[12], sysargs[13], sysargs[14])
syscall.f1 = syscall.a2 // on amd64 a2 stores the float return. On 32bit platforms floats aren't support
}
if ty.NumOut() == 0 {
return nil
}
outType := ty.Out(0)
v := reflect.New(outType).Elem()
switch outType.Kind() {
case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
v.SetUint(uint64(syscall.a1))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v.SetInt(int64(syscall.a1))
case reflect.Bool:
v.SetBool(byte(syscall.a1) != 0)
case reflect.UnsafePointer:
// We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer
v.SetPointer(*(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1)))
case reflect.Ptr:
v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem()
case reflect.Func:
// wrap this C function in a nicely typed Go function
v = reflect.New(outType)
RegisterFunc(v.Interface(), syscall.a1)
case reflect.String:
v.SetString(strings.GoString(syscall.a1))
case reflect.Float32:
// NOTE: syscall.r2 is only the floating return value on 64bit platforms.
// On 32bit platforms syscall.r2 is the upper part of a 64bit return.
// On 386, x87 FPU returns floats as float64 in ST(0), so we read as float64 and convert.
// On PPC64LE, C ABI converts float32 to double in FPR, so we read as float64.
// On S390X (big-endian), float32 is in upper 32 bits of the 64-bit FP register.
switch runtime.GOARCH {
case "386":
v.SetFloat(math.Float64frombits(uint64(syscall.f1) | (uint64(syscall.f2) << 32)))
case "ppc64le":
v.SetFloat(math.Float64frombits(uint64(syscall.f1)))
case "s390x":
// S390X is big-endian: float32 in upper 32 bits of 64-bit register
v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1 >> 32))))
default:
v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1))))
}
case reflect.Float64:
// NOTE: syscall.r2 is only the floating return value on 64bit platforms.
// On 32bit platforms syscall.r2 is the upper part of a 64bit return.
if is32bit {
v.SetFloat(math.Float64frombits(uint64(syscall.f1) | (uint64(syscall.f2) << 32)))
} else {
v.SetFloat(math.Float64frombits(uint64(syscall.f1)))
}
case reflect.Struct:
v = getStruct(outType, *syscall)
default:
panic("purego: unsupported return kind: " + outType.Kind().String())
}
if len(args) > 0 {
// reuse args slice instead of allocating one when possible
args[0] = v
return args[:1]
} else {
return []reflect.Value{v}
}
})
fn.Set(v)
}
func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat func(x uintptr), addStack func(x uintptr), numInts *int, numFloats *int, numStack *int) []any {
const is32bit = unsafe.Sizeof(uintptr(0)) == 4
switch v.Kind() {
case reflect.String:
ptr := strings.CString(v.String())
keepAlive = append(keepAlive, ptr)
addInt(uintptr(unsafe.Pointer(ptr)))
case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
addInt(uintptr(v.Uint()))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
addInt(uintptr(v.Int()))
case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
addInt(v.Pointer())
case reflect.Func:
addInt(NewCallback(v.Interface()))
case reflect.Bool:
if v.Bool() {
addInt(1)
} else {
addInt(0)
}
case reflect.Float32:
// On S390X big-endian, float32 goes in upper 32 bits of 64-bit FP register
if runtime.GOARCH == "s390x" {
addFloat(uintptr(math.Float32bits(float32(v.Float()))) << 32)
} else {
addFloat(uintptr(math.Float32bits(float32(v.Float()))))
}
case reflect.Float64:
if is32bit {
bits := math.Float64bits(v.Float())
addFloat(uintptr(bits))
addFloat(uintptr(bits >> 32))
} else {
addFloat(uintptr(math.Float64bits(v.Float())))
}
case reflect.Struct:
keepAlive = addStruct(v, numInts, numFloats, numStack, addInt, addFloat, addStack, keepAlive)
default:
panic("purego: unsupported kind: " + v.Kind().String())
}
return keepAlive
}
// maxRegAllocStructSize is the biggest a struct can be while still fitting in registers.
// if it is bigger than this than enough space must be allocated on the heap and then passed into
// the function as the first parameter on amd64 or in R8 on arm64.
//
// If you change this make sure to update it in objc_runtime_darwin.go
const maxRegAllocStructSize = 16
func isAllSameFloat(ty reflect.Type) (allFloats bool, numFields int) {
allFloats = true
root := ty.Field(0).Type
for root.Kind() == reflect.Struct {
root = root.Field(0).Type
}
first := root.Kind()
if first != reflect.Float32 && first != reflect.Float64 {
allFloats = false
}
for i := 0; i < ty.NumField(); i++ {
f := ty.Field(i).Type
if f.Kind() == reflect.Struct {
var structNumFields int
allFloats, structNumFields = isAllSameFloat(f)
numFields += structNumFields
continue
}
numFields++
if f.Kind() != first {
allFloats = false
}
}
return allFloats, numFields
}
func checkStructFieldsSupported(ty reflect.Type) {
for i := 0; i < ty.NumField(); i++ {
f := ty.Field(i).Type
if f.Kind() == reflect.Array {
f = f.Elem()
} else if f.Kind() == reflect.Struct {
checkStructFieldsSupported(f)
continue
}
switch f.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer, reflect.Float64, reflect.Float32,
reflect.Bool:
default:
panic(fmt.Sprintf("purego: struct field type %s is not supported", f))
}
}
}
func ensureStructSupportedForRegisterFunc() {
if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
panic("purego: struct arguments are only supported on amd64 and arm64")
}
if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
panic("purego: struct arguments are only supported on darwin and linux")
}
}
func roundUpTo8(val uintptr) uintptr {
return (val + align8ByteMask) &^ align8ByteMask
}
func numOfFloatRegisters() int {
switch runtime.GOARCH {
case "amd64", "arm64", "loong64", "ppc64le", "riscv64":
return 8
case "s390x":
return 4
case "arm":
return 16
case "386":
// i386 SysV ABI passes all arguments on the stack, including floats
return 0
default:
// since this platform isn't supported and can therefore only access
// integer registers it is safest to return 8
return 8
}
}
func numOfIntegerRegisters() int {
switch runtime.GOARCH {
case "arm64", "loong64", "ppc64le", "riscv64":
return 8
case "amd64":
return 6
case "s390x":
// S390X uses R2-R6 for integer arguments
return 5
case "arm":
return 4
case "386":
// i386 SysV ABI passes all arguments on the stack
return 0
default:
// since this platform isn't supported and can therefore only access
// integer registers it is fine to return the maxArgs
return maxArgs
}
}
// estimateStackBytes estimates stack bytes needed for Darwin ARM64 validation.
// This is a conservative estimate used only for early error detection.
func estimateStackBytes(ty reflect.Type) int {
var numInts, numFloats int
var stackBytes int
for i := 0; i < ty.NumIn(); i++ {
arg := ty.In(i)
size := int(arg.Size())
// Check if this goes to register or stack
usesInt := arg.Kind() != reflect.Float32 && arg.Kind() != reflect.Float64
if usesInt && numInts < numOfIntegerRegisters() {
numInts++
} else if !usesInt && numFloats < numOfFloatRegisters() {
numFloats++
} else {
// Goes to stack - accumulate total bytes
stackBytes += size
}
}
// Round total to 8-byte boundary
if stackBytes > 0 && stackBytes%align8ByteSize != 0 {
stackBytes = int(roundUpTo8(uintptr(stackBytes)))
}
return stackBytes
}
golang-github-ebitengine-purego-0.10.1/func_test.go 0000664 0000000 0000000 00000042145 15207302613 0022254 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
package purego_test
import (
"bytes"
"errors"
"fmt"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"testing"
"unsafe"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/internal/load"
)
func getSystemLibrary() (string, error) {
switch runtime.GOOS {
case "darwin":
return "/usr/lib/libSystem.B.dylib", nil
case "freebsd":
return "libc.so.7", nil
case "linux":
return "libc.so.6", nil
case "netbsd":
return "libc.so", nil
case "windows":
return "ucrtbase.dll", nil
default:
return "", fmt.Errorf("GOOS=%s is not supported", runtime.GOOS)
}
}
func TestRegisterFunc_ConcurrentPointerReturn(t *testing.T) {
library, err := getSystemLibrary()
if err != nil {
t.Fatalf("couldn't get system library: %s", err)
}
libc, err := load.OpenLibrary(library)
if err != nil {
t.Fatalf("failed to dlopen: %s", err)
}
var alloc func(uint64) *byte
var free func(*byte)
purego.RegisterLibFunc(&alloc, libc, "malloc")
purego.RegisterLibFunc(&free, libc, "free")
var wg sync.WaitGroup
for i := 0; i < runtime.NumCPU(); i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
for j := 0; j < 400_000; j++ {
ptr := alloc(5)
if ptr == nil {
continue
}
free(ptr)
}
}(i)
}
wg.Wait()
}
func TestRegisterFunc(t *testing.T) {
library, err := getSystemLibrary()
if err != nil {
t.Fatalf("couldn't get system library: %s", err)
}
libc, err := load.OpenLibrary(library)
if err != nil {
t.Fatalf("failed to dlopen: %s", err)
}
var puts func(string)
purego.RegisterLibFunc(&puts, libc, "puts")
puts("Calling C from from Go without Cgo!")
}
func Test_qsort(t *testing.T) {
if runtime.GOARCH != "arm" && runtime.GOARCH != "arm64" && runtime.GOARCH != "386" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "riscv64" && runtime.GOARCH != "s390x" {
t.Skip("Platform doesn't support Floats")
return
}
library, err := getSystemLibrary()
if err != nil {
t.Fatalf("couldn't get system library: %s", err)
}
libc, err := load.OpenLibrary(library)
if err != nil {
t.Fatalf("failed to dlopen: %s", err)
}
data := []int{88, 56, 100, 2, 25}
sorted := []int{2, 25, 56, 88, 100}
compare := func(_ purego.CDecl, a, b *int) int {
return *a - *b
}
var qsort func(data []int, nitms uintptr, size uintptr, compar func(_ purego.CDecl, a, b *int) int)
purego.RegisterLibFunc(&qsort, libc, "qsort")
qsort(data, uintptr(len(data)), unsafe.Sizeof(int(0)), compare)
for i := range data {
if data[i] != sorted[i] {
t.Errorf("got %d wanted %d at %d", data[i], sorted[i], i)
}
}
}
func TestRegisterFunc_Floats(t *testing.T) {
if runtime.GOARCH != "arm" && runtime.GOARCH != "arm64" && runtime.GOARCH != "386" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "riscv64" && runtime.GOARCH != "s390x" {
t.Skip("Platform doesn't support Floats")
return
}
if runtime.GOOS == "windows" && runtime.GOARCH == "386" {
t.Skip("need a 32bit gcc to run this test") // TODO: find 32bit gcc for test
}
library, err := getSystemLibrary()
if err != nil {
t.Fatalf("couldn't get system library: %s", err)
}
libc, err := load.OpenLibrary(library)
if err != nil {
t.Fatalf("failed to dlopen: %s", err)
}
{
var strtof func(arg string) float32
purego.RegisterLibFunc(&strtof, libc, "strtof")
const (
arg = "2"
)
got := strtof(arg)
expected := float32(2)
if got != expected {
t.Errorf("strtof failed. got %f but wanted %f", got, expected)
}
}
{
var strtod func(arg string, ptr **byte) float64
purego.RegisterLibFunc(&strtod, libc, "strtod")
const (
arg = "1"
)
got := strtod(arg, nil)
expected := float64(1)
if got != expected {
t.Errorf("strtod failed. got %f but wanted %f", got, expected)
}
}
}
func TestRegisterLibFunc_Bool(t *testing.T) {
if runtime.GOARCH != "arm" && runtime.GOARCH != "arm64" && runtime.GOARCH != "386" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "riscv64" && runtime.GOARCH != "s390x" {
t.Skip("Platform doesn't support callbacks")
return
}
// this callback recreates the state where the return register
// contains other information but the least significant byte is false
cbFalse := purego.NewCallback(func() uintptr {
x := uint64(0x7F5948AE9A00)
return uintptr(x)
})
var runFalse func() bool
purego.RegisterFunc(&runFalse, cbFalse)
expected := false
if got := runFalse(); got != expected {
t.Errorf("runFalse failed. got %t but wanted %t", got, expected)
}
}
func TestABI(t *testing.T) {
if runtime.GOOS == "windows" && runtime.GOARCH == "386" {
t.Skip("need a 32bit gcc to run this test") // TODO: find 32bit gcc for test
}
libFileName := filepath.Join(t.TempDir(), "abitest.so")
t.Logf("Build %v", libFileName)
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "abitest", "abi_test.c")); err != nil {
t.Fatal(err)
}
lib, err := load.OpenLibrary(libFileName)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
defer func() {
if err := load.CloseLibrary(lib); err != nil {
t.Fatalf("failed to close library: %s", err)
}
}()
{
const cName = "stack_uint8_t"
const expect = 2047
var fn func(a, b, c, d, e, f, g, h uint32, i, j uint8, k uint32) uint32
purego.RegisterLibFunc(&fn, lib, cName)
res := fn(256, 512, 4, 8, 16, 32, 64, 128, 1, 2, 1024)
if res != expect {
t.Fatalf("%s: got %d, want %d", cName, res, expect)
}
}
{
const cName = "reg_uint8_t"
const expect = 1027
var fn func(a, b uint8, c uint32) uint32
purego.RegisterLibFunc(&fn, lib, cName)
res := fn(1, 2, 1024)
if res != expect {
t.Fatalf("%s: got %d, want %d", cName, res, expect)
}
}
{
const cName = "stack_string"
const expect = 255
var fn func(a, b, c, d, e, f, g, h uint32, i string) uint32
purego.RegisterLibFunc(&fn, lib, cName)
res := fn(1, 2, 4, 8, 16, 32, 64, 128, "test")
if res != expect {
t.Fatalf("%s: got %d, want %d", cName, res, expect)
}
}
{
const cName = "stack_8i32_3strings"
var fn func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, string, string, string)
purego.RegisterLibFunc(&fn, lib, cName)
buf := make([]byte, 256)
fn(&buf[0], uintptr(len(buf)), 1, 2, 3, 4, 5, 6, 7, 8, "foo", "bar", "baz")
res := string(buf[:bytes.IndexByte(buf, 0)])
const want = "1:2:3:4:5:6:7:8:foo:bar:baz"
if res != want {
t.Fatalf("%s: got %q, want %q", cName, res, want)
}
}
}
func TestABI_ArgumentPassing(t *testing.T) {
if runtime.GOOS == "windows" && runtime.GOARCH == "386" {
t.Skip("need a 32bit gcc to run this test") // TODO: find 32bit gcc for test
}
libFileName := filepath.Join(t.TempDir(), "abitest.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "abitest", "abi_test.c")); err != nil {
t.Fatal(err)
}
lib, err := load.OpenLibrary(libFileName)
if err != nil {
t.Fatalf("Failed to open library %q: %v", libFileName, err)
}
t.Cleanup(func() {
if err := load.CloseLibrary(lib); err != nil {
t.Errorf("Failed to close library: %v", err)
}
})
tests := []struct {
name string
fn any
cFn string
call func(any) string
want string
}{
{
name: "10_int32_baseline",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)),
cFn: "stack_10_int32",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10",
},
{
name: "11_int32",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)),
cFn: "stack_11_int32",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10:11",
},
{
name: "10_float32",
fn: new(func(*byte, uintptr, float32, float32, float32, float32, float32, float32, float32, float32, float32, float32)),
cFn: "stack_10_float32",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, float32, float32, float32, float32, float32, float32, float32, float32, float32, float32)))(&buf[0], 256, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0",
},
{
name: "mixed_stack_strings",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, string, bool, int32, string)),
cFn: "stack_mixed_stack_4args",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, string, bool, int32, string)))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, "foo", false, 99, "bar")
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:foo:0:99:bar",
},
{
name: "20_int32",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)),
cFn: "stack_20_int32",
call: func(f any) string {
buf := make([]byte, 512)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32, int32)))(&buf[0], 512, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10:11:12:13:14:15:16:17:18:19:20",
},
{
name: "8int_hfa2_stack",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y float32 })),
cFn: "stack_8int_hfa2_stack",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y float32 })))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, struct{ x, y float32 }{10.0, 20.0})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:10.0:20.0",
},
{
name: "8int_2structs_stack",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y int32 }, struct{ x, y int32 })),
cFn: "stack_8int_2structs_stack",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y int32 }, struct{ x, y int32 })))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, struct{ x, y int32 }{9, 10}, struct{ x, y int32 }{11, 12})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10:11:12",
},
{
name: "8float_hfa2_stack",
fn: new(func(*byte, uintptr, float32, float32, float32, float32, float32, float32, float32, float32, struct{ x, y float32 })),
cFn: "stack_8float_hfa2_stack",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, float32, float32, float32, float32, float32, float32, float32, float32, struct{ x, y float32 })))(&buf[0], 256, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, struct{ x, y float32 }{9.0, 10.0})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0",
},
{
name: "8int_hfa2_floatregs",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y float32 })),
cFn: "stack_8int_hfa2_floatregs",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y float32 })))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, struct{ x, y float32 }{10.0, 20.0})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:10.0:20.0",
},
{
name: "8int_int_struct_int",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y int32 }, int32)),
cFn: "stack_8int_int_struct_int",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y int32 }, int32)))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, 9, struct{ x, y int32 }{10, 11}, 12)
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10:11:12",
},
{
name: "8int_hfa4_stack",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y, z, w float32 })),
cFn: "stack_8int_hfa4_stack",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct{ x, y, z, w float32 })))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, struct{ x, y, z, w float32 }{10.0, 20.0, 30.0, 40.0})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:10.0:20.0:30.0:40.0",
},
{
name: "8int_mixed_struct",
fn: new(func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct {
a int32
b float32
})),
cFn: "stack_8int_mixed_struct",
call: func(f any) string {
buf := make([]byte, 256)
(*f.(*func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, struct {
a int32
b float32
})))(&buf[0], 256, 1, 2, 3, 4, 5, 6, 7, 8, struct {
a int32
b float32
}{9, 10.0})
return string(buf[:bytes.IndexByte(buf, 0)])
},
want: "1:2:3:4:5:6:7:8:9:10.0",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.name == "20_int32" && (runtime.GOOS != "darwin" || runtime.GOARCH != "arm64") {
t.Skip("20 int32 arguments only supported on Darwin ARM64 with smart stack checking")
}
if tt.name == "10_float32" && (runtime.GOARCH == "loong64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "s390x") {
t.Skip("float32 stack arguments not yet supported on this platform")
}
// Struct tests require Darwin ARM64 or AMD64
if strings.HasPrefix(tt.name, "8int_") && (runtime.GOOS != "darwin" || (runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64")) {
t.Skip("struct argument tests only supported on Darwin ARM64/AMD64")
}
if strings.HasPrefix(tt.name, "8float_") && (runtime.GOOS != "darwin" || (runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64")) {
t.Skip("struct argument tests only supported on Darwin ARM64/AMD64")
}
purego.RegisterLibFunc(tt.fn, lib, tt.cFn)
got := tt.call(tt.fn)
if got != tt.want {
t.Errorf("%s\n got: %q\n want: %q", tt.cFn, got, tt.want)
}
})
}
}
func TestABI_TooManyArguments(t *testing.T) {
if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
t.Skip("This test is specific to Darwin ARM64")
}
libFileName := filepath.Join(t.TempDir(), "abitest.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "abitest", "abi_test.c")); err != nil {
t.Fatal(err)
}
lib, err := load.OpenLibrary(libFileName)
if err != nil {
t.Fatalf("Failed to open library %q: %v", libFileName, err)
}
t.Cleanup(func() {
if err := load.CloseLibrary(lib); err != nil {
t.Errorf("Failed to close library: %v", err)
}
})
// Test that 35 int64 arguments (27 slots needed) exceeds the limit
t.Run("35_int64_exceeds_limit", func(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Logf("Got expected panic: %v", r)
} else {
t.Errorf("Expected panic but didn't get one")
}
}()
var fn func(*byte, uintptr, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64)
purego.RegisterLibFunc(&fn, lib, "stack_35_int64_exceeds")
})
}
func buildSharedLib(compilerEnv, libFile string, sources ...string) error {
out, err := exec.Command("go", "env", compilerEnv).Output()
if err != nil {
return fmt.Errorf("go env %s error: %w", compilerEnv, err)
}
compiler := strings.TrimSpace(string(out))
if compiler == "" {
return errors.New("compiler not found")
}
args := []string{"-shared", "-Wall", "-Werror", "-fPIC", "-o", libFile}
if runtime.GOARCH == "386" {
args = append(args, "-m32")
}
// macOS arm64 can run amd64 tests through Rossetta.
// Build the shared library based on the GOARCH and not
// the default behavior of the compiler.
if runtime.GOOS == "darwin" {
var arch string
switch runtime.GOARCH {
case "arm64":
arch = "arm64"
case "amd64":
arch = "x86_64"
default:
return fmt.Errorf("unknown macOS architecture %s", runtime.GOARCH)
}
args = append(args, "-arch", arch)
}
cmd := exec.Command(compiler, append(args, sources...)...)
if out, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("compile lib: %w\n%q\n%s", err, cmd, string(out))
}
return nil
}
golang-github-ebitengine-purego-0.10.1/gen.go 0000664 0000000 0000000 00000000223 15207302613 0021022 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package purego
//go:generate go run wincallback.go
golang-github-ebitengine-purego-0.10.1/go.mod 0000664 0000000 0000000 00000000055 15207302613 0021033 0 ustar 00root root 0000000 0000000 module github.com/ebitengine/purego
go 1.18
golang-github-ebitengine-purego-0.10.1/go.sum 0000664 0000000 0000000 00000000000 15207302613 0021046 0 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/go_runtime.go 0000664 0000000 0000000 00000000506 15207302613 0022425 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd || windows
package purego
import (
"unsafe"
)
//go:linkname runtime_cgocall runtime.cgocall
func runtime_cgocall(fn uintptr, arg unsafe.Pointer) int32 // from runtime/sys_libc.go
golang-github-ebitengine-purego-0.10.1/internal/ 0000775 0000000 0000000 00000000000 15207302613 0021541 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/buildtest/ 0000775 0000000 0000000 00000000000 15207302613 0023540 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/buildtest/main.go 0000664 0000000 0000000 00000000444 15207302613 0025015 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
//go:build !windows
package main
import (
_ "github.com/ebitengine/purego"
)
import "C"
// This file tests that build Cgo and purego at the same time succeeds to build (#189).
func main() {
}
golang-github-ebitengine-purego-0.10.1/internal/cgo/ 0000775 0000000 0000000 00000000000 15207302613 0022311 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/cgo/dlfcn_cgo_unix.go 0000664 0000000 0000000 00000002356 15207302613 0025627 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
//go:build freebsd || linux || netbsd
package cgo
/*
#cgo !netbsd LDFLAGS: -ldl
#include
#include
*/
import "C"
import (
"errors"
"unsafe"
)
func Dlopen(filename string, flag int) (uintptr, error) {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
handle := C.dlopen(cfilename, C.int(flag))
if handle == nil {
return 0, errors.New(C.GoString(C.dlerror()))
}
return uintptr(handle), nil
}
func Dlsym(handle uintptr, symbol string) (uintptr, error) {
csymbol := C.CString(symbol)
defer C.free(unsafe.Pointer(csymbol))
symbolAddr := C.dlsym(*(*unsafe.Pointer)(unsafe.Pointer(&handle)), csymbol)
if symbolAddr == nil {
return 0, errors.New(C.GoString(C.dlerror()))
}
return uintptr(symbolAddr), nil
}
func Dlclose(handle uintptr) error {
result := C.dlclose(*(*unsafe.Pointer)(unsafe.Pointer(&handle)))
if result != 0 {
return errors.New(C.GoString(C.dlerror()))
}
return nil
}
// all that is needed is to assign each dl function because then its
// symbol will then be made available to the linker and linked to inside dlfcn.go
var (
_ = C.dlopen
_ = C.dlsym
_ = C.dlerror
_ = C.dlclose
)
golang-github-ebitengine-purego-0.10.1/internal/cgo/empty.go 0000664 0000000 0000000 00000000277 15207302613 0024004 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package cgo
// Empty so that importing this package doesn't cause issue for certain platforms.
golang-github-ebitengine-purego-0.10.1/internal/cgo/syscall_cgo_unix.go 0000664 0000000 0000000 00000003677 15207302613 0026222 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build freebsd || (linux && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64)) || netbsd
package cgo
// this file is placed inside internal/cgo and not package purego
// because Cgo and assembly files can't be in the same package.
/*
#cgo !netbsd LDFLAGS: -ldl
#include
#include
#include
#include
typedef struct syscall15Args {
uintptr_t fn;
uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
uintptr_t f1, f2, f3, f4, f5, f6, f7, f8;
uintptr_t err;
} syscall15Args;
void syscall15(struct syscall15Args *args) {
assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0);
uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6,
uintptr_t a7, uintptr_t a8, uintptr_t a9, uintptr_t a10, uintptr_t a11, uintptr_t a12,
uintptr_t a13, uintptr_t a14, uintptr_t a15);
*(void**)(&func_name) = (void*)(args->fn);
uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9,
args->a10,args->a11,args->a12,args->a13,args->a14,args->a15);
args->a1 = r1;
args->err = errno;
}
*/
import "C"
import "unsafe"
// assign purego.syscall15XABI0 to the C version of this function.
var Syscall15XABI0 = unsafe.Pointer(C.syscall15)
//go:nosplit
func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
args := C.syscall15Args{
C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),
C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6),
C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12),
C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0,
}
C.syscall15(&args)
return uintptr(args.a1), 0, uintptr(args.err)
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ 0000775 0000000 0000000 00000000000 15207302613 0023140 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/fakecgo/abi_amd64.h 0000664 0000000 0000000 00000005353 15207302613 0025045 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These save the frame pointer, so in general, functions that use
// these should have zero frame size to suppress the automatic frame
// pointer, though it's harmless to not do this.
#ifdef GOOS_windows
// REGS_HOST_TO_ABI0_STACK is the stack bytes used by
// PUSH_REGS_HOST_TO_ABI0.
#define REGS_HOST_TO_ABI0_STACK (28*8 + 8)
// PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from
// the host ABI to Go ABI0 code. It saves all registers that are
// callee-save in the host ABI and caller-save in Go ABI0 and prepares
// for entry to Go.
//
// Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag.
// Clear the DF flag for the Go ABI.
// MXCSR matches the Go ABI, so we don't have to set that,
// and Go doesn't modify it, so we don't have to save it.
#define PUSH_REGS_HOST_TO_ABI0() \
PUSHFQ \
CLD \
ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \
MOVQ DI, (0*0)(SP) \
MOVQ SI, (1*8)(SP) \
MOVQ BP, (2*8)(SP) \
MOVQ BX, (3*8)(SP) \
MOVQ R12, (4*8)(SP) \
MOVQ R13, (5*8)(SP) \
MOVQ R14, (6*8)(SP) \
MOVQ R15, (7*8)(SP) \
MOVUPS X6, (8*8)(SP) \
MOVUPS X7, (10*8)(SP) \
MOVUPS X8, (12*8)(SP) \
MOVUPS X9, (14*8)(SP) \
MOVUPS X10, (16*8)(SP) \
MOVUPS X11, (18*8)(SP) \
MOVUPS X12, (20*8)(SP) \
MOVUPS X13, (22*8)(SP) \
MOVUPS X14, (24*8)(SP) \
MOVUPS X15, (26*8)(SP)
#define POP_REGS_HOST_TO_ABI0() \
MOVQ (0*0)(SP), DI \
MOVQ (1*8)(SP), SI \
MOVQ (2*8)(SP), BP \
MOVQ (3*8)(SP), BX \
MOVQ (4*8)(SP), R12 \
MOVQ (5*8)(SP), R13 \
MOVQ (6*8)(SP), R14 \
MOVQ (7*8)(SP), R15 \
MOVUPS (8*8)(SP), X6 \
MOVUPS (10*8)(SP), X7 \
MOVUPS (12*8)(SP), X8 \
MOVUPS (14*8)(SP), X9 \
MOVUPS (16*8)(SP), X10 \
MOVUPS (18*8)(SP), X11 \
MOVUPS (20*8)(SP), X12 \
MOVUPS (22*8)(SP), X13 \
MOVUPS (24*8)(SP), X14 \
MOVUPS (26*8)(SP), X15 \
ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \
POPFQ
#else
// SysV ABI
#define REGS_HOST_TO_ABI0_STACK (6*8)
// SysV MXCSR matches the Go ABI, so we don't have to set that,
// and Go doesn't modify it, so we don't have to save it.
// Both SysV and Go require DF to be cleared, so that's already clear.
// The SysV and Go frame pointer conventions are compatible.
#define PUSH_REGS_HOST_TO_ABI0() \
ADJSP $(REGS_HOST_TO_ABI0_STACK) \
MOVQ BP, (5*8)(SP) \
LEAQ (5*8)(SP), BP \
MOVQ BX, (0*8)(SP) \
MOVQ R12, (1*8)(SP) \
MOVQ R13, (2*8)(SP) \
MOVQ R14, (3*8)(SP) \
MOVQ R15, (4*8)(SP)
#define POP_REGS_HOST_TO_ABI0() \
MOVQ (0*8)(SP), BX \
MOVQ (1*8)(SP), R12 \
MOVQ (2*8)(SP), R13 \
MOVQ (3*8)(SP), R14 \
MOVQ (4*8)(SP), R15 \
MOVQ (5*8)(SP), BP \
ADJSP $-(REGS_HOST_TO_ABI0_STACK)
#endif
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/abi_arm64.h 0000664 0000000 0000000 00000002767 15207302613 0025071 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These macros save and restore the callee-saved registers
// from the stack, but they don't adjust stack pointer, so
// the user should prepare stack space in advance.
// SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space
// of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP).
//
// SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space
// of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP).
//
// R29 is not saved because Go will save and restore it.
#define SAVE_R19_TO_R28(offset) \
STP (R19, R20), ((offset)+0*8)(RSP) \
STP (R21, R22), ((offset)+2*8)(RSP) \
STP (R23, R24), ((offset)+4*8)(RSP) \
STP (R25, R26), ((offset)+6*8)(RSP) \
STP (R27, g), ((offset)+8*8)(RSP)
#define RESTORE_R19_TO_R28(offset) \
LDP ((offset)+0*8)(RSP), (R19, R20) \
LDP ((offset)+2*8)(RSP), (R21, R22) \
LDP ((offset)+4*8)(RSP), (R23, R24) \
LDP ((offset)+6*8)(RSP), (R25, R26) \
LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */
#define SAVE_F8_TO_F15(offset) \
FSTPD (F8, F9), ((offset)+0*8)(RSP) \
FSTPD (F10, F11), ((offset)+2*8)(RSP) \
FSTPD (F12, F13), ((offset)+4*8)(RSP) \
FSTPD (F14, F15), ((offset)+6*8)(RSP)
#define RESTORE_F8_TO_F15(offset) \
FLDPD ((offset)+0*8)(RSP), (F8, F9) \
FLDPD ((offset)+2*8)(RSP), (F10, F11) \
FLDPD ((offset)+4*8)(RSP), (F12, F13) \
FLDPD ((offset)+6*8)(RSP), (F14, F15)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/abi_loong64.h 0000664 0000000 0000000 00000003712 15207302613 0025417 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI0.
//
// These macros save and restore the callee-saved registers
// from the stack, but they don't adjust stack pointer, so
// the user should prepare stack space in advance.
// SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space
// of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3).
//
// SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space
// of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3).
//
// Note: g is R22
#define SAVE_R22_TO_R31(offset) \
MOVV g, ((offset)+(0*8))(R3) \
MOVV R23, ((offset)+(1*8))(R3) \
MOVV R24, ((offset)+(2*8))(R3) \
MOVV R25, ((offset)+(3*8))(R3) \
MOVV R26, ((offset)+(4*8))(R3) \
MOVV R27, ((offset)+(5*8))(R3) \
MOVV R28, ((offset)+(6*8))(R3) \
MOVV R29, ((offset)+(7*8))(R3) \
MOVV R30, ((offset)+(8*8))(R3) \
MOVV R31, ((offset)+(9*8))(R3)
#define SAVE_F24_TO_F31(offset) \
MOVD F24, ((offset)+(0*8))(R3) \
MOVD F25, ((offset)+(1*8))(R3) \
MOVD F26, ((offset)+(2*8))(R3) \
MOVD F27, ((offset)+(3*8))(R3) \
MOVD F28, ((offset)+(4*8))(R3) \
MOVD F29, ((offset)+(5*8))(R3) \
MOVD F30, ((offset)+(6*8))(R3) \
MOVD F31, ((offset)+(7*8))(R3)
#define RESTORE_R22_TO_R31(offset) \
MOVV ((offset)+(0*8))(R3), g \
MOVV ((offset)+(1*8))(R3), R23 \
MOVV ((offset)+(2*8))(R3), R24 \
MOVV ((offset)+(3*8))(R3), R25 \
MOVV ((offset)+(4*8))(R3), R26 \
MOVV ((offset)+(5*8))(R3), R27 \
MOVV ((offset)+(6*8))(R3), R28 \
MOVV ((offset)+(7*8))(R3), R29 \
MOVV ((offset)+(8*8))(R3), R30 \
MOVV ((offset)+(9*8))(R3), R31
#define RESTORE_F24_TO_F31(offset) \
MOVD ((offset)+(0*8))(R3), F24 \
MOVD ((offset)+(1*8))(R3), F25 \
MOVD ((offset)+(2*8))(R3), F26 \
MOVD ((offset)+(3*8))(R3), F27 \
MOVD ((offset)+(4*8))(R3), F28 \
MOVD ((offset)+(5*8))(R3), F29 \
MOVD ((offset)+(6*8))(R3), F30 \
MOVD ((offset)+(7*8))(R3), F31
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/abi_ppc64x.h 0000664 0000000 0000000 00000015065 15207302613 0025257 0 ustar 00root root 0000000 0000000 // 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.
// Macros for transitioning from the host ABI to Go ABI
//
// On PPC64/ELFv2 targets, the following registers are callee
// saved when called from C. They must be preserved before
// calling into Go which does not preserve any of them.
//
// R14-R31
// CR2-4
// VR20-31
// F14-F31
//
// xcoff(aix) and ELFv1 are similar, but may only require a
// subset of these.
//
// These macros assume a 16 byte aligned stack pointer. This
// is required by ELFv1, ELFv2, and AIX PPC64.
#define SAVE_GPR_SIZE (18*8)
#define SAVE_GPR(offset) \
MOVD R14, (offset+8*0)(R1) \
MOVD R15, (offset+8*1)(R1) \
MOVD R16, (offset+8*2)(R1) \
MOVD R17, (offset+8*3)(R1) \
MOVD R18, (offset+8*4)(R1) \
MOVD R19, (offset+8*5)(R1) \
MOVD R20, (offset+8*6)(R1) \
MOVD R21, (offset+8*7)(R1) \
MOVD R22, (offset+8*8)(R1) \
MOVD R23, (offset+8*9)(R1) \
MOVD R24, (offset+8*10)(R1) \
MOVD R25, (offset+8*11)(R1) \
MOVD R26, (offset+8*12)(R1) \
MOVD R27, (offset+8*13)(R1) \
MOVD R28, (offset+8*14)(R1) \
MOVD R29, (offset+8*15)(R1) \
MOVD g, (offset+8*16)(R1) \
MOVD R31, (offset+8*17)(R1)
#define RESTORE_GPR(offset) \
MOVD (offset+8*0)(R1), R14 \
MOVD (offset+8*1)(R1), R15 \
MOVD (offset+8*2)(R1), R16 \
MOVD (offset+8*3)(R1), R17 \
MOVD (offset+8*4)(R1), R18 \
MOVD (offset+8*5)(R1), R19 \
MOVD (offset+8*6)(R1), R20 \
MOVD (offset+8*7)(R1), R21 \
MOVD (offset+8*8)(R1), R22 \
MOVD (offset+8*9)(R1), R23 \
MOVD (offset+8*10)(R1), R24 \
MOVD (offset+8*11)(R1), R25 \
MOVD (offset+8*12)(R1), R26 \
MOVD (offset+8*13)(R1), R27 \
MOVD (offset+8*14)(R1), R28 \
MOVD (offset+8*15)(R1), R29 \
MOVD (offset+8*16)(R1), g \
MOVD (offset+8*17)(R1), R31
#define SAVE_FPR_SIZE (18*8)
#define SAVE_FPR(offset) \
FMOVD F14, (offset+8*0)(R1) \
FMOVD F15, (offset+8*1)(R1) \
FMOVD F16, (offset+8*2)(R1) \
FMOVD F17, (offset+8*3)(R1) \
FMOVD F18, (offset+8*4)(R1) \
FMOVD F19, (offset+8*5)(R1) \
FMOVD F20, (offset+8*6)(R1) \
FMOVD F21, (offset+8*7)(R1) \
FMOVD F22, (offset+8*8)(R1) \
FMOVD F23, (offset+8*9)(R1) \
FMOVD F24, (offset+8*10)(R1) \
FMOVD F25, (offset+8*11)(R1) \
FMOVD F26, (offset+8*12)(R1) \
FMOVD F27, (offset+8*13)(R1) \
FMOVD F28, (offset+8*14)(R1) \
FMOVD F29, (offset+8*15)(R1) \
FMOVD F30, (offset+8*16)(R1) \
FMOVD F31, (offset+8*17)(R1)
#define RESTORE_FPR(offset) \
FMOVD (offset+8*0)(R1), F14 \
FMOVD (offset+8*1)(R1), F15 \
FMOVD (offset+8*2)(R1), F16 \
FMOVD (offset+8*3)(R1), F17 \
FMOVD (offset+8*4)(R1), F18 \
FMOVD (offset+8*5)(R1), F19 \
FMOVD (offset+8*6)(R1), F20 \
FMOVD (offset+8*7)(R1), F21 \
FMOVD (offset+8*8)(R1), F22 \
FMOVD (offset+8*9)(R1), F23 \
FMOVD (offset+8*10)(R1), F24 \
FMOVD (offset+8*11)(R1), F25 \
FMOVD (offset+8*12)(R1), F26 \
FMOVD (offset+8*13)(R1), F27 \
FMOVD (offset+8*14)(R1), F28 \
FMOVD (offset+8*15)(R1), F29 \
FMOVD (offset+8*16)(R1), F30 \
FMOVD (offset+8*17)(R1), F31
// Save and restore VR20-31 (aka VSR56-63). These
// macros must point to a 16B aligned offset.
#define SAVE_VR_SIZE (12*16)
#define SAVE_VR(offset, rtmp) \
MOVD $(offset+16*0), rtmp \
STVX V20, (rtmp)(R1) \
MOVD $(offset+16*1), rtmp \
STVX V21, (rtmp)(R1) \
MOVD $(offset+16*2), rtmp \
STVX V22, (rtmp)(R1) \
MOVD $(offset+16*3), rtmp \
STVX V23, (rtmp)(R1) \
MOVD $(offset+16*4), rtmp \
STVX V24, (rtmp)(R1) \
MOVD $(offset+16*5), rtmp \
STVX V25, (rtmp)(R1) \
MOVD $(offset+16*6), rtmp \
STVX V26, (rtmp)(R1) \
MOVD $(offset+16*7), rtmp \
STVX V27, (rtmp)(R1) \
MOVD $(offset+16*8), rtmp \
STVX V28, (rtmp)(R1) \
MOVD $(offset+16*9), rtmp \
STVX V29, (rtmp)(R1) \
MOVD $(offset+16*10), rtmp \
STVX V30, (rtmp)(R1) \
MOVD $(offset+16*11), rtmp \
STVX V31, (rtmp)(R1)
#define RESTORE_VR(offset, rtmp) \
MOVD $(offset+16*0), rtmp \
LVX (rtmp)(R1), V20 \
MOVD $(offset+16*1), rtmp \
LVX (rtmp)(R1), V21 \
MOVD $(offset+16*2), rtmp \
LVX (rtmp)(R1), V22 \
MOVD $(offset+16*3), rtmp \
LVX (rtmp)(R1), V23 \
MOVD $(offset+16*4), rtmp \
LVX (rtmp)(R1), V24 \
MOVD $(offset+16*5), rtmp \
LVX (rtmp)(R1), V25 \
MOVD $(offset+16*6), rtmp \
LVX (rtmp)(R1), V26 \
MOVD $(offset+16*7), rtmp \
LVX (rtmp)(R1), V27 \
MOVD $(offset+16*8), rtmp \
LVX (rtmp)(R1), V28 \
MOVD $(offset+16*9), rtmp \
LVX (rtmp)(R1), V29 \
MOVD $(offset+16*10), rtmp \
LVX (rtmp)(R1), V30 \
MOVD $(offset+16*11), rtmp \
LVX (rtmp)(R1), V31
// LR and CR are saved in the caller's frame. The callee must
// make space for all other callee-save registers.
#define SAVE_ALL_REG_SIZE (SAVE_GPR_SIZE+SAVE_FPR_SIZE+SAVE_VR_SIZE)
// Stack a frame and save all callee-save registers following the
// host OS's ABI. Fortunately, this is identical for AIX, ELFv1, and
// ELFv2. All host ABIs require the stack pointer to maintain 16 byte
// alignment, and save the callee-save registers in the same places.
//
// To restate, R1 is assumed to be aligned when this macro is used.
// This assumes the caller's frame is compliant with the host ABI.
// CR and LR are saved into the caller's frame per the host ABI.
// R0 is initialized to $0 as expected by Go.
#define STACK_AND_SAVE_HOST_TO_GO_ABI(extra) \
MOVD LR, R0 \
MOVD R0, 16(R1) \
MOVW CR, R0 \
MOVD R0, 8(R1) \
MOVDU R1, -(extra)-FIXED_FRAME-SAVE_ALL_REG_SIZE(R1) \
SAVE_GPR(extra+FIXED_FRAME) \
SAVE_FPR(extra+FIXED_FRAME+SAVE_GPR_SIZE) \
SAVE_VR(extra+FIXED_FRAME+SAVE_GPR_SIZE+SAVE_FPR_SIZE, R0) \
MOVD $0, R0
// This unstacks the frame, restoring all callee-save registers
// as saved by STACK_AND_SAVE_HOST_TO_GO_ABI.
//
// R0 is not guaranteed to contain $0 after this macro.
#define UNSTACK_AND_RESTORE_GO_TO_HOST_ABI(extra) \
RESTORE_GPR(extra+FIXED_FRAME) \
RESTORE_FPR(extra+FIXED_FRAME+SAVE_GPR_SIZE) \
RESTORE_VR(extra+FIXED_FRAME+SAVE_GPR_SIZE+SAVE_FPR_SIZE, R0) \
ADD $(extra+FIXED_FRAME+SAVE_ALL_REG_SIZE), R1 \
MOVD 16(R1), R0 \
MOVD R0, LR \
MOVD 8(R1), R0 \
MOVW R0, CR
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_386.s 0000664 0000000 0000000 00000001343 15207302613 0024505 0 ustar 00root root 0000000 0000000 // Copyright 2009 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.
#include "textflag.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT, $28-16
MOVL BP, 24(SP)
MOVL BX, 20(SP)
MOVL SI, 16(SP)
MOVL DI, 12(SP)
MOVL ctxt+12(FP), AX
MOVL AX, 8(SP)
MOVL a+4(FP), AX
MOVL AX, 4(SP)
MOVL fn+0(FP), AX
MOVL AX, 0(SP)
CALL runtime·cgocallback(SB)
MOVL 12(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), BX
MOVL 24(SP), BP
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_amd64.s 0000664 0000000 0000000 00000001636 15207302613 0025105 0 ustar 00root root 0000000 0000000 // Copyright 2009 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.
#include "textflag.h"
#include "abi_amd64.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
// This signature is known to SWIG, so we can't change it.
TEXT crosscall2(SB), NOSPLIT, $0-0
PUSH_REGS_HOST_TO_ABI0()
// Make room for arguments to cgocallback.
ADJSP $0x18
#ifndef GOOS_windows
MOVQ DI, 0x0(SP) // fn
MOVQ SI, 0x8(SP) // arg
// Skip n in DX.
MOVQ CX, 0x10(SP) // ctxt
#else
MOVQ CX, 0x0(SP) // fn
MOVQ DX, 0x8(SP) // arg
// Skip n in R8.
MOVQ R9, 0x10(SP) // ctxt
#endif
CALL runtime·cgocallback(SB)
ADJSP $-0x18
POP_REGS_HOST_TO_ABI0()
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_arm.s 0000664 0000000 0000000 00000003325 15207302613 0024746 0 ustar 00root root 0000000 0000000 // Copyright 2012 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.
#include "textflag.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
SUB $(8*9), R13 // Reserve space for the floating point registers.
// The C arguments arrive in R0, R1, R2, and R3. We want to
// pass R0, R1, and R3 to Go, so we push those on the stack.
// Also, save C callee-save registers R4-R12.
MOVM.WP [R0, R1, R3, R4, R5, R6, R7, R8, R9, g, R11, R12], (R13)
// Finally, save the link register R14. This also puts the
// arguments we pushed for cgocallback where they need to be,
// starting at 4(R13).
MOVW.W R14, -4(R13)
// Save VFP callee-saved registers D8-D15 (same as S16-S31).
// Note: We always save these since we target hard-float ABI.
MOVD F8, (13*4+8*1)(R13)
MOVD F9, (13*4+8*2)(R13)
MOVD F10, (13*4+8*3)(R13)
MOVD F11, (13*4+8*4)(R13)
MOVD F12, (13*4+8*5)(R13)
MOVD F13, (13*4+8*6)(R13)
MOVD F14, (13*4+8*7)(R13)
MOVD F15, (13*4+8*8)(R13)
BL runtime·load_g(SB)
// We set up the arguments to cgocallback when saving registers above.
BL runtime·cgocallback(SB)
MOVD (13*4+8*1)(R13), F8
MOVD (13*4+8*2)(R13), F9
MOVD (13*4+8*3)(R13), F10
MOVD (13*4+8*4)(R13), F11
MOVD (13*4+8*5)(R13), F12
MOVD (13*4+8*6)(R13), F13
MOVD (13*4+8*7)(R13), F14
MOVD (13*4+8*8)(R13), F15
MOVW.P 4(R13), R14
MOVM.IAW (R13), [R0, R1, R3, R4, R5, R6, R7, R8, R9, g, R11, R12]
ADD $(8*9), R13
MOVW R14, R15
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_arm64.s 0000664 0000000 0000000 00000002005 15207302613 0025112 0 ustar 00root root 0000000 0000000 // Copyright 2015 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.
#include "textflag.h"
#include "abi_arm64.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
/*
* We still need to save all callee save register as before, and then
* push 3 args for fn (R0, R1, R3), skipping R2.
* Also note that at procedure entry in gc world, 8(RSP) will be the
* first arg.
*/
SUB $(8*24), RSP
STP (R0, R1), (8*1)(RSP)
MOVD R3, (8*3)(RSP)
SAVE_R19_TO_R28(8*4)
SAVE_F8_TO_F15(8*14)
STP (R29, R30), (8*22)(RSP)
// Initialize Go ABI environment
BL runtime·load_g(SB)
BL runtime·cgocallback(SB)
RESTORE_R19_TO_R28(8*4)
RESTORE_F8_TO_F15(8*14)
LDP (8*22)(RSP), (R29, R30)
ADD $(8*24), RSP
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_loong64.s 0000664 0000000 0000000 00000002112 15207302613 0025450 0 ustar 00root root 0000000 0000000 // 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.
#include "textflag.h"
#include "abi_loong64.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
/*
* We still need to save all callee save register as before, and then
* push 3 args for fn (R4, R5, R7), skipping R6.
* Also note that at procedure entry in gc world, 8(R29) will be the
* first arg.
*/
ADDV $(-23*8), R3
MOVV R4, (1*8)(R3) // fn unsafe.Pointer
MOVV R5, (2*8)(R3) // a unsafe.Pointer
MOVV R7, (3*8)(R3) // ctxt uintptr
SAVE_R22_TO_R31((4*8))
SAVE_F24_TO_F31((14*8))
MOVV R1, (22*8)(R3)
// Initialize Go ABI environment
JAL runtime·load_g(SB)
JAL runtime·cgocallback(SB)
RESTORE_R22_TO_R31((4*8))
RESTORE_F24_TO_F31((14*8))
MOVV (22*8)(R3), R1
ADDV $(23*8), R3
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_ppc64le.s 0000664 0000000 0000000 00000004021 15207302613 0025436 0 ustar 00root root 0000000 0000000 // Copyright 2014 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.
#include "textflag.h"
#include "abi_ppc64x.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
//
// This is a simplified version that only saves GPR and FPR registers,
// not vector registers. This keeps the stack frame smaller to avoid
// exceeding the nosplit stack limit.
//
// On PPC64LE ELFv2, callee-save registers are:
// R14-R31 (18 GPRs = 144 bytes)
// F14-F31 (18 FPRs = 144 bytes)
// CR2-CR4 (saved in CR field)
//
// Stack layout (must be 16-byte aligned):
// 32 (FIXED_FRAME) + 24 (args) + 144 (GPR) + 144 (FPR) = 344
// Rounded to 352 for 16-byte alignment.
#define FIXED_FRAME 32
#define SAVE_SIZE 352
#define GPR_OFFSET (FIXED_FRAME+24)
#define FPR_OFFSET (GPR_OFFSET+SAVE_GPR_SIZE)
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
// Save LR and CR in caller's frame per ELFv2 ABI
MOVD LR, R0
MOVD R0, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
// Allocate our stack frame
MOVDU R1, -SAVE_SIZE(R1)
// Save TOC (R2) in case needed
MOVD R2, 24(R1)
// Save callee-save GPRs
SAVE_GPR(GPR_OFFSET)
// Save callee-save FPRs
SAVE_FPR(FPR_OFFSET)
// Initialize R0 to 0 as expected by Go
MOVD $0, R0
// Load the current g.
BL runtime·load_g(SB)
// Set up arguments for cgocallback
MOVD R3, FIXED_FRAME+0(R1) // fn unsafe.Pointer
MOVD R4, FIXED_FRAME+8(R1) // a unsafe.Pointer
// Skip R5 = n uint32
MOVD R6, FIXED_FRAME+16(R1) // ctxt uintptr
BL runtime·cgocallback(SB)
// Restore callee-save FPRs
RESTORE_FPR(FPR_OFFSET)
// Restore callee-save GPRs
RESTORE_GPR(GPR_OFFSET)
// Restore TOC
MOVD 24(R1), R2
// Deallocate stack frame
ADD $SAVE_SIZE, R1
// Restore LR and CR from caller's frame
MOVD 16(R1), R0
MOVD R0, LR
MOVD 8(R1), R0
MOVW R0, CR
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_riscv64.s 0000664 0000000 0000000 00000003635 15207302613 0025473 0 ustar 00root root 0000000 0000000 // Copyright 2020 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.
#include "textflag.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
/*
* Push arguments for fn (X10, X11, X13), along with all callee-save
* registers. Note that at procedure entry the first argument is at
* 8(X2).
*/
ADD $(-8*29), X2
MOV X10, (8*1)(X2) // fn unsafe.Pointer
MOV X11, (8*2)(X2) // a unsafe.Pointer
MOV X13, (8*3)(X2) // ctxt uintptr
MOV X8, (8*4)(X2)
MOV X9, (8*5)(X2)
MOV X18, (8*6)(X2)
MOV X19, (8*7)(X2)
MOV X20, (8*8)(X2)
MOV X21, (8*9)(X2)
MOV X22, (8*10)(X2)
MOV X23, (8*11)(X2)
MOV X24, (8*12)(X2)
MOV X25, (8*13)(X2)
MOV X26, (8*14)(X2)
MOV g, (8*15)(X2)
MOV X1, (8*16)(X2)
MOVD F8, (8*17)(X2)
MOVD F9, (8*18)(X2)
MOVD F18, (8*19)(X2)
MOVD F19, (8*20)(X2)
MOVD F20, (8*21)(X2)
MOVD F21, (8*22)(X2)
MOVD F22, (8*23)(X2)
MOVD F23, (8*24)(X2)
MOVD F24, (8*25)(X2)
MOVD F25, (8*26)(X2)
MOVD F26, (8*27)(X2)
MOVD F27, (8*28)(X2)
// Initialize Go ABI environment
CALL runtime·load_g(SB)
CALL runtime·cgocallback(SB)
MOV (8*4)(X2), X8
MOV (8*5)(X2), X9
MOV (8*6)(X2), X18
MOV (8*7)(X2), X19
MOV (8*8)(X2), X20
MOV (8*9)(X2), X21
MOV (8*10)(X2), X22
MOV (8*11)(X2), X23
MOV (8*12)(X2), X24
MOV (8*13)(X2), X25
MOV (8*14)(X2), X26
MOV (8*15)(X2), g
MOV (8*16)(X2), X1
MOVD (8*17)(X2), F8
MOVD (8*18)(X2), F9
MOVD (8*19)(X2), F18
MOVD (8*20)(X2), F19
MOVD (8*21)(X2), F20
MOVD (8*22)(X2), F21
MOVD (8*23)(X2), F22
MOVD (8*24)(X2), F23
MOVD (8*25)(X2), F24
MOVD (8*26)(X2), F25
MOVD (8*27)(X2), F26
MOVD (8*28)(X2), F27
ADD $(8*29), X2
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/asm_s390x.s 0000664 0000000 0000000 00000002521 15207302613 0025052 0 ustar 00root root 0000000 0000000 // Copyright 2016 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.
#include "textflag.h"
// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
// Start with standard C stack frame layout and linkage.
// Save R6-R15 in the register save area of the calling function.
STMG R6, R15, 48(R15)
// Allocate 96 bytes on the stack.
MOVD $-96(R15), R15
// Save F8-F15 in our stack frame.
FMOVD F8, 32(R15)
FMOVD F9, 40(R15)
FMOVD F10, 48(R15)
FMOVD F11, 56(R15)
FMOVD F12, 64(R15)
FMOVD F13, 72(R15)
FMOVD F14, 80(R15)
FMOVD F15, 88(R15)
// Initialize Go ABI environment.
BL runtime·load_g(SB)
MOVD R2, 8(R15) // fn unsafe.Pointer
MOVD R3, 16(R15) // a unsafe.Pointer
// Skip R4 = n uint32
MOVD R5, 24(R15) // ctxt uintptr
BL runtime·cgocallback(SB)
FMOVD 32(R15), F8
FMOVD 40(R15), F9
FMOVD 48(R15), F10
FMOVD 56(R15), F11
FMOVD 64(R15), F12
FMOVD 72(R15), F13
FMOVD 80(R15), F14
FMOVD 88(R15), F15
// De-allocate stack frame.
MOVD $96(R15), R15
// Restore R6-R15.
LMG 48(R15), R6, R15
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/callbacks.go 0000664 0000000 0000000 00000007176 15207302613 0025421 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import (
_ "unsafe"
)
// TODO: decide if we need _runtime_cgo_panic_internal
//go:linkname x_cgo_init_trampoline x_cgo_init_trampoline
//go:linkname _cgo_init _cgo_init
var x_cgo_init_trampoline byte
var _cgo_init = &x_cgo_init_trampoline
// Creates a new system thread without updating any Go state.
//
// This method is invoked during shared library loading to create a new OS
// thread to perform the runtime initialization. This method is similar to
// _cgo_sys_thread_start except that it doesn't update any Go state.
//go:linkname x_cgo_thread_start_trampoline x_cgo_thread_start_trampoline
//go:linkname _cgo_thread_start _cgo_thread_start
var x_cgo_thread_start_trampoline byte
var _cgo_thread_start = &x_cgo_thread_start_trampoline
// Notifies that the runtime has been initialized.
//
// We currently block at every CGO entry point (via _cgo_wait_runtime_init_done)
// to ensure that the runtime has been initialized before the CGO call is
// executed. This is necessary for shared libraries where we kickoff runtime
// initialization in a separate thread and return without waiting for this
// thread to complete the init.
//go:linkname x_cgo_notify_runtime_init_done_trampoline x_cgo_notify_runtime_init_done_trampoline
//go:linkname _cgo_notify_runtime_init_done _cgo_notify_runtime_init_done
var x_cgo_notify_runtime_init_done_trampoline byte
var _cgo_notify_runtime_init_done = &x_cgo_notify_runtime_init_done_trampoline
// Indicates whether a dummy thread key has been created or not.
//
// When calling go exported function from C, we register a destructor
// callback, for a dummy thread key, by using pthread_key_create.
//go:linkname _cgo_pthread_key_created _cgo_pthread_key_created
var x_cgo_pthread_key_created uintptr
var _cgo_pthread_key_created = &x_cgo_pthread_key_created
// Set the x_crosscall2_ptr C function pointer variable point to crosscall2.
// It's for the runtime package to call at init time.
func set_crosscall2() {
// nothing needs to be done here for fakecgo
// because it's possible to just call cgocallback directly
}
//go:linkname _set_crosscall2 runtime.set_crosscall2
var _set_crosscall2 = set_crosscall2
// Store the g into the thread-specific value.
// So that pthread_key_destructor will dropm when the thread is exiting.
//go:linkname x_cgo_bindm_trampoline x_cgo_bindm_trampoline
//go:linkname _cgo_bindm _cgo_bindm
var x_cgo_bindm_trampoline byte
var _cgo_bindm = &x_cgo_bindm_trampoline
// TODO: decide if we need x_cgo_set_context_function
// TODO: decide if we need _cgo_yield
var (
// In Go 1.20 the race detector was rewritten to pure Go
// on darwin. This means that when CGO_ENABLED=0 is set
// fakecgo is built with race detector code. This is not
// good since this code is pretending to be C. The go:norace
// pragma is not enough, since it only applies to the native
// ABIInternal function. The ABIO wrapper (which is necessary,
// since all references to text symbols from assembly will use it)
// does not inherit the go:norace pragma, so it will still be
// instrumented by the race detector.
//
// To circumvent this issue, using closure calls in the
// assembly, which forces the compiler to use the ABIInternal
// native implementation (which has go:norace) instead.
threadentry_call = threadentry
x_cgo_init_call = x_cgo_init
x_cgo_setenv_call = x_cgo_setenv
x_cgo_unsetenv_call = x_cgo_unsetenv
x_cgo_thread_start_call = x_cgo_thread_start
)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/doc.go 0000664 0000000 0000000 00000002370 15207302613 0024236 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
// Package fakecgo implements the Cgo runtime (runtime/cgo) entirely in Go.
// This allows code that calls into C to function properly when CGO_ENABLED=0.
//
// # Goals
//
// fakecgo attempts to replicate the same naming structure as in the runtime.
// For example, functions that have the prefix "gcc_*" are named "go_*".
// This makes it easier to port other GOOSs and GOARCHs as well as to keep
// it in sync with runtime/cgo.
//
// # Support
//
// Currently, fakecgo only supports macOS on amd64 & arm64. It also cannot
// be used with -buildmode=c-archive because that requires special initialization
// that fakecgo does not implement at the moment.
//
// # Usage
//
// Using fakecgo is easy just import _ "github.com/ebitengine/purego" and then
// set the environment variable CGO_ENABLED=0.
// The recommended usage for fakecgo is to prefer using runtime/cgo if possible
// but if cross-compiling or fast build times are important fakecgo is available.
// Purego will pick which ever Cgo runtime is available and prefer the one that
// comes with Go (runtime/cgo).
package fakecgo
//go:generate go run gen.go
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/fakecgo.go 0000664 0000000 0000000 00000000657 15207302613 0025076 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import _ "unsafe"
// setg_trampoline calls setg with the G provided
func setg_trampoline(setg uintptr, G uintptr)
// call5 takes fn the C function and 5 arguments and calls the function with those arguments
func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/freebsd.go 0000664 0000000 0000000 00000001431 15207302613 0025100 0 ustar 00root root 0000000 0000000 // Copyright 2010 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.
//go:build freebsd && !cgo
package fakecgo
import _ "unsafe" // for go:linkname
// Supply environ and __progname, because we don't
// link against the standard FreeBSD crt0.o and the
// libc dynamic library needs them.
// Note: when building with cross-compiling or CGO_ENABLED=0, add
// the following argument to `go` so that these symbols are defined by
// making fakecgo the Cgo.
// -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std"
//go:linkname _environ environ
//go:linkname _progname __progname
//go:cgo_export_dynamic environ
//go:cgo_export_dynamic __progname
var _environ uintptr
var _progname uintptr
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/gen.go 0000664 0000000 0000000 00000017644 15207302613 0024254 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build ignore
package main
import (
"bytes"
"fmt"
"go/format"
"log"
"os"
"path/filepath"
"sort"
"strings"
"text/template"
)
var templateSymbols = template.Must(template.New("symbols").Funcs(funcs).Parse(
`// Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build {{.Tag}}
package fakecgo
{{ imports .Symbols }}
{{- range $di := .DynamicImports }}
{{- range $sym := $di.Symbols }}
//go:cgo_import_dynamic purego_{{ $sym }} {{ $sym }} "{{ $di.Name }}"
{{- end }}
{{- end }}
{{ range .Symbols -}}
//go:nosplit
//go:norace
func {{.Name}}(
{{- range .Args -}}
{{- if .Name -}}
{{.Name}} {{.Type}},
{{- end -}}
{{- end -}}) {{.Return}} {
{{- if .Return -}}
{{- if eq .Return "unsafe.Pointer" -}}
ret :=
{{- else -}}
return {{.Return}}(
{{- end -}}
{{- end -}}
call5({{.Name}}ABI0,
{{- range .Args}}
{{- if .Name -}}
{{- if hasPrefix .Type "*" -}}
uintptr(unsafe.Pointer({{.Name}})),
{{- else -}}
uintptr({{.Name}}),
{{- end -}}
{{- else -}}
0,
{{- end -}}
{{- end -}}
) {{/* end of call5 */}}
{{- if .Return -}}
{{- if eq .Return "unsafe.Pointer"}}
// this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer
return *(*unsafe.Pointer)(unsafe.Pointer(&ret))
{{- else -}}
) {{/* end of cast */}}
{{- end -}}
{{- end}}
}
{{end}}
{{- range .Symbols }}
//go:linkname _{{.Name}} _{{.Name}}
var _{{.Name}} uint8
var {{.Name}}ABI0 = uintptr(unsafe.Pointer(&_{{.Name}}))
{{ end }}
`))
var templateTrampolinesStubs = template.Must(template.New("trampolines").Parse(
`// Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build {{.Tag}}
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
{{ range .Symbols }}
TEXT _{{.Name}}(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_{{.Name}}(SB)
{{ end -}}
`))
type Arg struct {
Name string
Type string
}
type Symbol struct {
Name string
Args [5]Arg
Return string
GOOSes []string // empty means all GOOSes
}
var (
libcSymbols = []Symbol{
{"malloc", [5]Arg{{"size", "uintptr"}}, "unsafe.Pointer", nil},
{"free", [5]Arg{{"ptr", "unsafe.Pointer"}}, "", nil},
{"setenv", [5]Arg{{"name", "*byte"}, {"value", "*byte"}, {"overwrite", "int32"}}, "int32", nil},
{"unsetenv", [5]Arg{{"name", "*byte"}}, "int32", nil},
{"sigfillset", [5]Arg{{"set", "*sigset_t"}}, "int32", nil},
{"nanosleep", [5]Arg{{"ts", "*syscall.Timespec"}, {"rem", "*syscall.Timespec"}}, "int32", nil},
{"abort", [5]Arg{}, "", nil},
{"sigaltstack", [5]Arg{{"ss", "*stack_t"}, {"old_ss", "*stack_t"}}, "int32", []string{"netbsd"}},
}
pthreadSymbols = []Symbol{
{"pthread_attr_init", [5]Arg{{"attr", "*pthread_attr_t"}}, "int32", nil},
{"pthread_create", [5]Arg{{"thread", "*pthread_t"}, {"attr", "*pthread_attr_t"}, {"start", "unsafe.Pointer"}, {"arg", "unsafe.Pointer"}}, "int32", nil},
{"pthread_detach", [5]Arg{{"thread", "pthread_t"}}, "int32", nil},
{"pthread_sigmask", [5]Arg{{"how", "sighow"}, {"ign", "*sigset_t"}, {"oset", "*sigset_t"}}, "int32", nil},
{"pthread_self", [5]Arg{}, "pthread_t", []string{"darwin"}},
{"pthread_get_stacksize_np", [5]Arg{{"thread", "pthread_t"}}, "size_t", []string{"darwin"}},
{"pthread_attr_getstacksize", [5]Arg{{"attr", "*pthread_attr_t"}, {"stacksize", "*size_t"}}, "int32", []string{"linux", "freebsd", "netbsd"}},
{"pthread_attr_setstacksize", [5]Arg{{"attr", "*pthread_attr_t"}, {"size", "size_t"}}, "int32", []string{"darwin"}},
{"pthread_attr_destroy", [5]Arg{{"attr", "*pthread_attr_t"}}, "int32", []string{"linux", "freebsd", "netbsd"}},
{"pthread_mutex_lock", [5]Arg{{"mutex", "*pthread_mutex_t"}}, "int32", nil},
{"pthread_mutex_unlock", [5]Arg{{"mutex", "*pthread_mutex_t"}}, "int32", nil},
{"pthread_cond_broadcast", [5]Arg{{"cond", "*pthread_cond_t"}}, "int32", nil},
{"pthread_setspecific", [5]Arg{{"key", "pthread_key_t"}, {"value", "unsafe.Pointer"}}, "int32", nil},
}
)
var funcs = map[string]any{
"hasPrefix": strings.HasPrefix,
"imports": imports,
}
var GOOSes = []string{"darwin", "freebsd", "linux", "netbsd"}
func imports(symbols []Symbol) string {
if len(symbols) == 0 {
return ""
}
imports := make(map[string]struct{})
imports["unsafe"] = struct{}{}
for _, s := range symbols {
for _, arg := range s.Args {
if pkg, _, found := strings.Cut(arg.Type, "."); found {
pkg = strings.TrimPrefix(pkg, "*")
imports[pkg] = struct{}{}
}
}
}
if len(imports) == 1 {
return `import "unsafe"`
}
result := make([]string, 0, len(imports))
for imp := range imports {
result = append(result, imp)
}
sort.Strings(result)
var sb strings.Builder
sb.WriteString("import (")
for _, imp := range result {
sb.WriteString("\n\t\"")
sb.WriteString(imp)
sb.WriteString("\"")
}
sb.WriteString("\n)")
return sb.String()
}
// filterSymbols filters the symbols by GOOS.
// If goos is empty, it returns symbols that are not specific to any GOOS.
func filterSymbols(symbols []Symbol, goos string) []Symbol {
filtered := make([]Symbol, 0, len(symbols))
for _, s := range symbols {
if (s.GOOSes == nil && goos == "") || contains(s.GOOSes, goos) {
filtered = append(filtered, s)
}
}
return filtered
}
func contains(slice []string, item string) bool {
for _, s := range slice {
if s == item {
return true
}
}
return false
}
func execute(t *template.Template, path string, data any) error {
var buf bytes.Buffer
if err := t.Execute(&buf, data); err != nil {
return err
}
if filepath.Ext(path) == ".go" {
source, err := format.Source(buf.Bytes())
if err != nil {
return err
}
buf.Reset()
buf.Write(source)
}
return os.WriteFile(path, buf.Bytes(), 0644)
}
func symbolsNames(symbols []Symbol) []string {
names := make([]string, len(symbols))
for i, s := range symbols {
names[i] = s.Name
}
return names
}
type dynamicImport struct {
Name string
Symbols []string
}
type fileContent struct {
Tag string
Symbols []Symbol
DynamicImports []dynamicImport
}
func run() error {
allSymbols := append(append([]Symbol{}, libcSymbols...), pthreadSymbols...)
goosAgnosticContent := fileContent{
Symbols: filterSymbols(allSymbols, ""),
Tag: "!cgo && (" + strings.Join(GOOSes, " || ") + ")",
}
if err := execute(templateSymbols, "zsymbols.go", goosAgnosticContent); err != nil {
return err
}
if err := execute(templateTrampolinesStubs, "ztrampolines_stubs.s", goosAgnosticContent); err != nil {
return err
}
goosAgnosticLibCSymbols := filterSymbols(libcSymbols, "")
goosAgnosticPthreadSymbols := filterSymbols(pthreadSymbols, "")
for _, goos := range GOOSes {
goosSymbols := filterSymbols(allSymbols, goos)
var libcSO, pthreadSO string
switch goos {
case "darwin":
libcSO = "/usr/lib/libSystem.B.dylib"
pthreadSO = "/usr/lib/libSystem.B.dylib"
case "freebsd":
libcSO = "libc.so.7"
pthreadSO = "libpthread.so"
case "linux":
libcSO = "libc.so.6"
pthreadSO = "libpthread.so.0"
case "netbsd":
libcSO = "libc.so"
pthreadSO = "libpthread.so"
default:
return fmt.Errorf("unsupported OS: %s", goos)
}
located := fileContent{
DynamicImports: []dynamicImport{
{libcSO, symbolsNames(append(goosAgnosticLibCSymbols, filterSymbols(libcSymbols, goos)...))},
{pthreadSO, symbolsNames(append(goosAgnosticPthreadSymbols, filterSymbols(pthreadSymbols, goos)...))},
},
Symbols: goosSymbols,
Tag: "!cgo",
}
if err := execute(templateSymbols, fmt.Sprintf("zsymbols_%s.go", goos), located); err != nil {
return err
}
if len(goosSymbols) != 0 {
if err := execute(templateTrampolinesStubs, fmt.Sprintf("ztrampolines_%s.s", goos), located); err != nil {
return err
}
}
}
return nil
}
func main() {
if err := run(); err != nil {
log.Fatal(err)
}
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_darwin.go 0000664 0000000 0000000 00000004521 15207302613 0025442 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo
package fakecgo
import "unsafe"
//go:nosplit
//go:norace
func _cgo_sys_thread_start(ts *ThreadStart) {
var attr pthread_attr_t
var ign, oset sigset_t
var p pthread_t
var size size_t
var err int
sigfillset(&ign)
pthread_sigmask(SIG_SETMASK, &ign, &oset)
size = pthread_get_stacksize_np(pthread_self())
pthread_attr_init(&attr)
pthread_attr_setstacksize(&attr, size)
// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
ts.g.stackhi = uintptr(size)
err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
pthread_sigmask(SIG_SETMASK, &oset, nil)
if err != 0 {
print("fakecgo: pthread_create failed: ")
println(err)
abort()
}
}
// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
//
//go:linkname x_threadentry_trampoline threadentry_trampoline
var x_threadentry_trampoline byte
var threadentry_trampolineABI0 = &x_threadentry_trampoline
//go:nosplit
//go:norace
func threadentry(v unsafe.Pointer) unsafe.Pointer {
ts := *(*ThreadStart)(v)
free(v)
// TODO: support ios
//#if TARGET_OS_IPHONE
// darwin_arm_init_thread_exception_port();
//#endif
setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
// faking funcs in go is a bit a... involved - but the following works :)
fn := uintptr(unsafe.Pointer(&ts.fn))
(*(*func())(unsafe.Pointer(&fn)))()
return nil
}
// here we will store a pointer to the provided setg func
var setg_func uintptr
// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c)
// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us
// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup
// This function can't be go:systemstack since go is not in a state where the systemcheck would work.
//
//go:nosplit
//go:norace
func x_cgo_init(g *G, setg uintptr) {
var size size_t
setg_func = setg
size = pthread_get_stacksize_np(pthread_self())
g.stacklo = uintptr(unsafe.Add(unsafe.Pointer(&size), -size+4096))
//TODO: support ios
//#if TARGET_OS_IPHONE
// darwin_arm_init_mach_exception_handler();
// darwin_arm_init_thread_exception_port();
// init_working_dir();
//#endif
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_freebsd.go 0000664 0000000 0000000 00000006204 15207302613 0025570 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo
package fakecgo
import "unsafe"
//go:nosplit
func _cgo_sys_thread_start(ts *ThreadStart) {
var attr pthread_attr_t
var ign, oset sigset_t
var p pthread_t
var size size_t
var err int
// fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
sigfillset(&ign)
pthread_sigmask(SIG_SETMASK, &ign, &oset)
pthread_attr_init(&attr)
pthread_attr_getstacksize(&attr, &size)
// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
ts.g.stackhi = uintptr(size)
err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
pthread_sigmask(SIG_SETMASK, &oset, nil)
if err != 0 {
print("fakecgo: pthread_create failed: ")
println(err)
abort()
}
}
// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
//
//go:linkname x_threadentry_trampoline threadentry_trampoline
var x_threadentry_trampoline byte
var threadentry_trampolineABI0 = &x_threadentry_trampoline
//go:nosplit
func threadentry(v unsafe.Pointer) unsafe.Pointer {
ts := *(*ThreadStart)(v)
free(v)
setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
// faking funcs in go is a bit a... involved - but the following works :)
fn := uintptr(unsafe.Pointer(&ts.fn))
(*(*func())(unsafe.Pointer(&fn)))()
return nil
}
// here we will store a pointer to the provided setg func
var setg_func uintptr
// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c)
// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us
// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup
// This function can't be go:systemstack since go is not in a state where the systemcheck would work.
//
//go:nosplit
func x_cgo_init(g *G, setg uintptr) {
var size size_t
var attr *pthread_attr_t
/* The memory sanitizer distributed with versions of clang
before 3.8 has a bug: if you call mmap before malloc, mmap
may return an address that is later overwritten by the msan
library. Avoid this problem by forcing a call to malloc
here, before we ever call malloc.
This is only required for the memory sanitizer, so it's
unfortunate that we always run it. It should be possible
to remove this when we no longer care about versions of
clang before 3.8. The test for this is
misc/cgo/testsanitizers.
GCC works hard to eliminate a seemingly unnecessary call to
malloc, so we actually use the memory we allocate. */
setg_func = setg
attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr)))
if attr == nil {
println("fakecgo: malloc failed")
abort()
}
pthread_attr_init(attr)
pthread_attr_getstacksize(attr, &size)
// runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))`
// but this should be OK since we are taking the address of the first variable in this function.
g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096
pthread_attr_destroy(attr)
free(unsafe.Pointer(attr))
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_libinit.go 0000664 0000000 0000000 00000004331 15207302613 0025607 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import (
"syscall"
"unsafe"
)
var (
pthread_g pthread_key_t
runtime_init_cond = PTHREAD_COND_INITIALIZER
runtime_init_mu = PTHREAD_MUTEX_INITIALIZER
runtime_init_done int
)
//go:nosplit
//go:norace
func x_cgo_notify_runtime_init_done() {
pthread_mutex_lock(&runtime_init_mu)
runtime_init_done = 1
pthread_cond_broadcast(&runtime_init_cond)
pthread_mutex_unlock(&runtime_init_mu)
}
// Store the g into a thread-specific value associated with the pthread key pthread_g.
// And pthread_key_destructor will dropm when the thread is exiting.
//
//go:norace
func x_cgo_bindm(g unsafe.Pointer) {
// We assume this will always succeed, otherwise, there might be extra M leaking,
// when a C thread exits after a cgo call.
// We only invoke this function once per thread in runtime.needAndBindM,
// and the next calls just reuse the bound m.
pthread_setspecific(pthread_g, g)
}
// _cgo_try_pthread_create retries pthread_create if it fails with
// EAGAIN.
//
//go:nosplit
//go:norace
func _cgo_try_pthread_create(thread *pthread_t, attr *pthread_attr_t, pfn unsafe.Pointer, arg *ThreadStart) int {
var ts syscall.Timespec
// tries needs to be the same type as syscall.Timespec.Nsec
// but the fields are int32 on 32bit and int64 on 64bit.
// tries is assigned to syscall.Timespec.Nsec in order to match its type.
tries := ts.Nsec
var err int
for tries = 0; tries < 20; tries++ {
// inlined this call because it ran out of stack when inlining was disabled
err = int(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(pfn), uintptr(unsafe.Pointer(arg)), 0))
if err == 0 {
// inlined this call because it ran out of stack when inlining was disabled
call5(pthread_detachABI0, uintptr(*thread), 0, 0, 0, 0)
return 0
}
if err != int(syscall.EAGAIN) {
return err
}
ts.Sec = 0
ts.Nsec = (tries + 1) * 1000 * 1000 // Milliseconds.
// inlined this call because it ran out of stack when inlining was disabled
call5(nanosleepABI0, uintptr(unsafe.Pointer(&ts)), 0, 0, 0, 0)
}
return int(syscall.EAGAIN)
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_linux.go 0000664 0000000 0000000 00000006203 15207302613 0025314 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo
package fakecgo
import "unsafe"
//go:nosplit
func _cgo_sys_thread_start(ts *ThreadStart) {
var attr pthread_attr_t
var ign, oset sigset_t
var p pthread_t
var size size_t
var err int
//fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
sigfillset(&ign)
pthread_sigmask(SIG_SETMASK, &ign, &oset)
pthread_attr_init(&attr)
pthread_attr_getstacksize(&attr, &size)
// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
ts.g.stackhi = uintptr(size)
err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
pthread_sigmask(SIG_SETMASK, &oset, nil)
if err != 0 {
print("fakecgo: pthread_create failed: ")
println(err)
abort()
}
}
// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
//
//go:linkname x_threadentry_trampoline threadentry_trampoline
var x_threadentry_trampoline byte
var threadentry_trampolineABI0 = &x_threadentry_trampoline
//go:nosplit
func threadentry(v unsafe.Pointer) unsafe.Pointer {
ts := *(*ThreadStart)(v)
free(v)
setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
// faking funcs in go is a bit a... involved - but the following works :)
fn := uintptr(unsafe.Pointer(&ts.fn))
(*(*func())(unsafe.Pointer(&fn)))()
return nil
}
// here we will store a pointer to the provided setg func
var setg_func uintptr
// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c)
// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us
// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup
// This function can't be go:systemstack since go is not in a state where the systemcheck would work.
//
//go:nosplit
func x_cgo_init(g *G, setg uintptr) {
var size size_t
var attr *pthread_attr_t
/* The memory sanitizer distributed with versions of clang
before 3.8 has a bug: if you call mmap before malloc, mmap
may return an address that is later overwritten by the msan
library. Avoid this problem by forcing a call to malloc
here, before we ever call malloc.
This is only required for the memory sanitizer, so it's
unfortunate that we always run it. It should be possible
to remove this when we no longer care about versions of
clang before 3.8. The test for this is
misc/cgo/testsanitizers.
GCC works hard to eliminate a seemingly unnecessary call to
malloc, so we actually use the memory we allocate. */
setg_func = setg
attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr)))
if attr == nil {
println("fakecgo: malloc failed")
abort()
}
pthread_attr_init(attr)
pthread_attr_getstacksize(attr, &size)
// runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))`
// but this should be OK since we are taking the address of the first variable in this function.
g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096
pthread_attr_destroy(attr)
free(unsafe.Pointer(attr))
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_netbsd.go 0000664 0000000 0000000 00000006404 15207302613 0025437 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo && (amd64 || arm64)
package fakecgo
import "unsafe"
//go:nosplit
func _cgo_sys_thread_start(ts *ThreadStart) {
var attr pthread_attr_t
var ign, oset sigset_t
var p pthread_t
var size size_t
var err int
// fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
sigfillset(&ign)
pthread_sigmask(SIG_SETMASK, &ign, &oset)
pthread_attr_init(&attr)
pthread_attr_getstacksize(&attr, &size)
// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
ts.g.stackhi = uintptr(size)
err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
pthread_sigmask(SIG_SETMASK, &oset, nil)
if err != 0 {
print("fakecgo: pthread_create failed: ")
println(err)
abort()
}
}
// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
//
//go:linkname x_threadentry_trampoline threadentry_trampoline
var x_threadentry_trampoline byte
var threadentry_trampolineABI0 = &x_threadentry_trampoline
//go:nosplit
func threadentry(v unsafe.Pointer) unsafe.Pointer {
var ss stack_t
ts := *(*ThreadStart)(v)
free(v)
// On NetBSD, a new thread inherits the signal stack of the
// creating thread. That confuses minit, so we remove that
// signal stack here before calling the regular mstart. It's
// a bit baroque to remove a signal stack here only to add one
// in minit, but it's a simple change that keeps NetBSD
// working like other OS's. At this point all signals are
// blocked, so there is no race.
ss.ss_flags = SS_DISABLE
sigaltstack(&ss, nil)
setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
// faking funcs in go is a bit a... involved - but the following works :)
fn := uintptr(unsafe.Pointer(&ts.fn))
(*(*func())(unsafe.Pointer(&fn)))()
return nil
}
// here we will store a pointer to the provided setg func
var setg_func uintptr
//go:nosplit
func x_cgo_init(g *G, setg uintptr) {
var size size_t
var attr *pthread_attr_t
/* The memory sanitizer distributed with versions of clang
before 3.8 has a bug: if you call mmap before malloc, mmap
may return an address that is later overwritten by the msan
library. Avoid this problem by forcing a call to malloc
here, before we ever call malloc.
This is only required for the memory sanitizer, so it's
unfortunate that we always run it. It should be possible
to remove this when we no longer care about versions of
clang before 3.8. The test for this is
misc/cgo/testsanitizers.
GCC works hard to eliminate a seemingly unnecessary call to
malloc, so we actually use the memory we allocate. */
setg_func = setg
attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr)))
if attr == nil {
println("fakecgo: malloc failed")
abort()
}
pthread_attr_init(attr)
pthread_attr_getstacksize(attr, &size)
// runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))`
// but this should be OK since we are taking the address of the first variable in this function.
g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096
pthread_attr_destroy(attr)
free(unsafe.Pointer(attr))
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_setenv.go 0000664 0000000 0000000 00000000527 15207302613 0025464 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
//go:nosplit
//go:norace
func x_cgo_setenv(arg *[2]*byte) {
setenv(arg[0], arg[1], 1)
}
//go:nosplit
//go:norace
func x_cgo_unsetenv(arg *[1]*byte) {
unsetenv(arg[0])
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/go_util.go 0000664 0000000 0000000 00000002522 15207302613 0025132 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import "unsafe"
// _cgo_thread_start is split into three parts in cgo since only one part is system dependent (keep it here for easier handling)
// _cgo_thread_start(ThreadStart *arg) (runtime/cgo/gcc_util.c)
// This get's called instead of the go code for creating new threads
// -> pthread_* stuff is used, so threads are setup correctly for C
// If this is missing, TLS is only setup correctly on thread 1!
// This function should be go:systemstack instead of go:nosplit (but that requires runtime)
//
//go:nosplit
//go:norace
func x_cgo_thread_start(arg *ThreadStart) {
var ts *ThreadStart
// Make our own copy that can persist after we return.
// _cgo_tsan_acquire();
ts = (*ThreadStart)(malloc(unsafe.Sizeof(*ts)))
// _cgo_tsan_release();
if ts == nil {
println("fakecgo: out of memory in thread_start")
abort()
}
// *ts = *arg would cause a writebarrier so copy using slices
const ptrSize = unsafe.Sizeof(uintptr(0))
s1 := unsafe.Slice((*uintptr)(unsafe.Pointer(ts)), unsafe.Sizeof(*ts)/ptrSize)
s2 := unsafe.Slice((*uintptr)(unsafe.Pointer(arg)), unsafe.Sizeof(*arg)/ptrSize)
for i := range s2 {
s1[i] = s2[i]
}
_cgo_sys_thread_start(ts) // OS-dependent half
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/iscgo.go 0000664 0000000 0000000 00000001305 15207302613 0024572 0 ustar 00root root 0000000 0000000 // Copyright 2010 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.
//go:build !cgo && (darwin || freebsd || linux || netbsd)
// The runtime package contains an uninitialized definition
// for runtime·iscgo. Override it to tell the runtime we're here.
// There are various function pointers that should be set too,
// but those depend on dynamic linker magic to get initialized
// correctly, and sometimes they break. This variable is a
// backup: it depends only on old C style static linking rules.
package fakecgo
import _ "unsafe" // for go:linkname
//go:linkname _iscgo runtime.iscgo
var _iscgo bool = true
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/libcgo.go 0000664 0000000 0000000 00000001672 15207302613 0024734 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
type (
size_t uintptr
// Sources:
// Darwin (32 bytes) - https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/_types.h#L74
// FreeBSD (32 bytes) - https://github.com/DoctorWkt/xv6-freebsd/blob/d2a294c2a984baed27676068b15ed9a29b06ab6f/include/signal.h#L98C9-L98C21
// Linux (128 bytes) - https://github.com/torvalds/linux/blob/ab75170520d4964f3acf8bb1f91d34cbc650688e/arch/x86/include/asm/signal.h#L25
sigset_t [128]byte
pthread_attr_t [64]byte
pthread_t int
pthread_key_t uint64
)
// for pthread_sigmask:
type sighow int32
const (
SIG_BLOCK sighow = 0
SIG_UNBLOCK sighow = 1
SIG_SETMASK sighow = 2
)
type G struct {
stacklo uintptr
stackhi uintptr
}
type ThreadStart struct {
g *G
tls *uintptr
fn uintptr
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/libcgo_darwin.go 0000664 0000000 0000000 00000000671 15207302613 0026276 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
type (
pthread_mutex_t struct {
sig int64
opaque [56]byte
}
pthread_cond_t struct {
sig int64
opaque [40]byte
}
)
var (
PTHREAD_COND_INITIALIZER = pthread_cond_t{sig: 0x3CB0B1BB}
PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{sig: 0x32AAABA7}
)
type stack_t struct {
/* not implemented */
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/libcgo_freebsd.go 0000664 0000000 0000000 00000000524 15207302613 0026421 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
type (
pthread_cond_t uintptr
pthread_mutex_t uintptr
)
var (
PTHREAD_COND_INITIALIZER = pthread_cond_t(0)
PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0)
)
type stack_t struct {
/* not implemented */
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/libcgo_linux.go 0000664 0000000 0000000 00000000524 15207302613 0026146 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
type (
pthread_cond_t [48]byte
pthread_mutex_t [48]byte
)
var (
PTHREAD_COND_INITIALIZER = pthread_cond_t{}
PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{}
)
type stack_t struct {
/* not implemented */
}
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/libcgo_netbsd.go 0000664 0000000 0000000 00000001176 15207302613 0026272 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build !cgo
package fakecgo
type (
pthread_cond_t uintptr
pthread_mutex_t uintptr
)
var (
PTHREAD_COND_INITIALIZER = pthread_cond_t(0)
PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0)
)
// Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/compat/linux/arch/m68k/linux_signal.h#L133
type stack_t struct {
ss_sp uintptr
ss_flags int32
ss_size uintptr
}
// Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/sys/signal.h#L261
const SS_DISABLE = 0x004
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/netbsd.go 0000664 0000000 0000000 00000001056 15207302613 0024750 0 ustar 00root root 0000000 0000000 // Copyright 2010 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.
//go:build netbsd
package fakecgo
import _ "unsafe" // for go:linkname
// Supply environ and __progname, because we don't
// link against the standard NetBSD crt0.o and the
// libc dynamic library needs them.
//go:linkname _environ environ
//go:linkname _progname __progname
//go:linkname ___ps_strings __ps_strings
var (
_environ uintptr
_progname uintptr
___ps_strings uintptr
)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/setenv.go 0000664 0000000 0000000 00000001221 15207302613 0024767 0 ustar 00root root 0000000 0000000 // Copyright 2011 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.
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import _ "unsafe" // for go:linkname
//go:linkname x_cgo_setenv_trampoline x_cgo_setenv_trampoline
//go:linkname _cgo_setenv runtime._cgo_setenv
var x_cgo_setenv_trampoline byte
var _cgo_setenv = &x_cgo_setenv_trampoline
//go:linkname x_cgo_unsetenv_trampoline x_cgo_unsetenv_trampoline
//go:linkname _cgo_unsetenv runtime._cgo_unsetenv
var x_cgo_unsetenv_trampoline byte
var _cgo_unsetenv = &x_cgo_unsetenv_trampoline
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_386.s 0000664 0000000 0000000 00000005662 15207302613 0026272 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build !cgo && (freebsd || linux)
#include "textflag.h"
#include "go_asm.h"
// These trampolines map the gcc ABI to Go ABI0 and then call into the Go equivalent functions.
// On i386, both GCC and Go use stack-based calling conventions.
//
// When C calls a function, the stack looks like:
// 0(SP) = return address
// 4(SP) = arg1
// 8(SP) = arg2
// ...
//
// When we declare a Go function with frame size $N-0, Go's prologue
// effectively does SUB $N, SP, so the C arguments shift up by N bytes:
// N+0(SP) = return address
// N+4(SP) = arg1
// N+8(SP) = arg2
//
// Go ABI0 on 386 expects arguments starting at 0(FP) which equals N+4(SP)
// after the prologue (where N is the local frame size).
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $8-0
// C args at 12(SP) and 16(SP) after frame setup (8 bytes local + 4 bytes ret addr)
// Go function expects args at 0(SP) and 4(SP) in local frame
MOVL 12(SP), AX // first C arg
MOVL 16(SP), BX // second C arg
MOVL AX, 0(SP) // Go arg 1
MOVL BX, 4(SP) // Go arg 2
MOVL ·x_cgo_init_call(SB), CX
MOVL (CX), CX
CALL CX
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $4-0
// C args at 8(SP) after frame setup (4 bytes local + 4 bytes ret addr)
MOVL 8(SP), AX // first C arg
MOVL AX, 0(SP) // Go arg 1
MOVL ·x_cgo_thread_start_call(SB), CX
MOVL (CX), CX
CALL CX
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $4-0
MOVL 8(SP), AX // first C arg
MOVL AX, 0(SP) // Go arg 1
MOVL ·x_cgo_setenv_call(SB), CX
MOVL (CX), CX
CALL CX
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $4-0
MOVL 8(SP), AX // first C arg
MOVL AX, 0(SP) // Go arg 1
MOVL ·x_cgo_unsetenv_call(SB), CX
MOVL (CX), CX
CALL CX
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0
CALL ·x_cgo_notify_runtime_init_done(SB)
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_bindm(SB)
RET
// func setg_trampoline(setg uintptr, g uintptr)
// This is called from Go, so args are at normal FP positions
TEXT ·setg_trampoline(SB), NOSPLIT, $4-8
MOVL g+4(FP), AX
MOVL setg+0(FP), BX
// setg expects g in 0(SP)
MOVL AX, 0(SP)
CALL BX
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $4-0
MOVL 8(SP), AX // first C arg
MOVL AX, 0(SP) // Go arg 1
MOVL ·threadentry_call(SB), CX
MOVL (CX), CX
CALL CX
RET
TEXT ·call5(SB), NOSPLIT, $20-28
MOVL fn+0(FP), AX
MOVL a1+4(FP), BX
MOVL a2+8(FP), CX
MOVL a3+12(FP), DX
MOVL a4+16(FP), SI
MOVL a5+20(FP), DI
// Place arguments on local stack frame for C calling convention
MOVL BX, 0(SP) // a1
MOVL CX, 4(SP) // a2
MOVL DX, 8(SP) // a3
MOVL SI, 12(SP) // a4
MOVL DI, 16(SP) // a5
CALL AX
MOVL AX, r1+24(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_amd64.s 0000664 0000000 0000000 00000004433 15207302613 0026660 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || linux || freebsd)
/*
trampoline for emulating required C functions for cgo in go (see cgo.go)
(we convert cdecl calling convention to go and vice-versa)
C Calling convention cdecl used here (we only need integer args):
1. arg: DI
2. arg: SI
3. arg: DX
4. arg: CX
5. arg: R8
6. arg: R9
We don't need floats with these functions -> AX=0
return value will be in AX
temporary register is R11
*/
#include "textflag.h"
#include "go_asm.h"
#include "abi_amd64.h"
// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions.
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16
MOVQ DI, AX
MOVQ SI, BX
MOVQ ·x_cgo_init_call(SB), R11
MOVQ (R11), R11
CALL R11
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8
MOVQ DI, AX
MOVQ ·x_cgo_thread_start_call(SB), R11
MOVQ (R11), R11
CALL R11
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8
MOVQ DI, AX
MOVQ ·x_cgo_setenv_call(SB), R11
MOVQ (R11), R11
CALL R11
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8
MOVQ DI, AX
MOVQ ·x_cgo_unsetenv_call(SB), R11
MOVQ (R11), R11
CALL R11
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0
JMP ·x_cgo_notify_runtime_init_done(SB)
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
JMP ·x_cgo_bindm(SB)
// func setg_trampoline(setg uintptr, g uintptr)
TEXT ·setg_trampoline(SB), NOSPLIT, $0-16
MOVQ G+8(FP), DI
MOVQ setg+0(FP), R11
XORL AX, AX
CALL R11
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $0
// See crosscall2.
PUSH_REGS_HOST_TO_ABI0()
// X15 is designated by Go as a fixed zero register.
// Calling directly into ABIInternal, ensure it is zero.
PXOR X15, X15
MOVQ DI, AX
MOVQ ·threadentry_call(SB), R11
MOVQ (R11), R11
CALL R11
POP_REGS_HOST_TO_ABI0()
RET
TEXT ·call5(SB), NOSPLIT, $0-56
MOVQ fn+0(FP), R11
MOVQ a1+8(FP), DI
MOVQ a2+16(FP), SI
MOVQ a3+24(FP), DX
MOVQ a4+32(FP), CX
MOVQ a5+40(FP), R8
XORL AX, AX // no floats
PUSHQ BP // save BP
MOVQ SP, BP // save SP inside BP bc BP is callee-saved
SUBQ $16, SP // allocate space for alignment
ANDQ $-16, SP // align on 16 bytes for SSE
CALL R11
MOVQ BP, SP // get SP back
POPQ BP // restore BP
MOVQ AX, ret+48(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_arm.s 0000664 0000000 0000000 00000003425 15207302613 0026524 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build !cgo && (freebsd || linux)
#include "textflag.h"
#include "go_asm.h"
// These trampolines map the gcc ABI to Go ABI0 and then call into the Go equivalent functions.
// On ARM32, Go ABI0 uses stack-based calling convention.
// Arguments are placed on the stack starting at 4(SP) after the prologue.
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $8-0
MOVW R0, 4(R13)
MOVW R1, 8(R13)
MOVW ·x_cgo_init_call(SB), R12
MOVW (R12), R12
CALL (R12)
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8-0
MOVW R0, 4(R13)
MOVW ·x_cgo_thread_start_call(SB), R12
MOVW (R12), R12
CALL (R12)
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8-0
MOVW R0, 4(R13)
MOVW ·x_cgo_setenv_call(SB), R12
MOVW (R12), R12
CALL (R12)
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8-0
MOVW R0, 4(R13)
MOVW ·x_cgo_unsetenv_call(SB), R12
MOVW (R12), R12
CALL (R12)
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0
CALL ·x_cgo_notify_runtime_init_done(SB)
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_bindm(SB)
RET
// func setg_trampoline(setg uintptr, g uintptr)
TEXT ·setg_trampoline(SB), NOSPLIT, $0-8
MOVW G+4(FP), R0
MOVW setg+0(FP), R12
BL (R12)
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $8-0
// See crosscall2.
MOVW R0, 4(R13)
MOVW ·threadentry_call(SB), R12
MOVW (R12), R12
CALL (R12)
RET
TEXT ·call5(SB), NOSPLIT, $8-28
MOVW fn+0(FP), R12
MOVW a1+4(FP), R0
MOVW a2+8(FP), R1
MOVW a3+12(FP), R2
MOVW a4+16(FP), R3
MOVW a5+20(FP), R4
// Store 5th arg below SP (in local frame area)
MOVW R4, arg5-8(SP)
// Align SP to 8 bytes for call (required by ARM AAPCS)
SUB $8, R13
CALL (R12)
ADD $8, R13
MOVW R0, r1+24(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_arm64.s 0000664 0000000 0000000 00000003543 15207302613 0026677 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux)
#include "textflag.h"
#include "go_asm.h"
#include "abi_arm64.h"
// These trampolines map the gcc ABI to Go ABIInternal and then calls into the Go equivalent functions.
// Note that C arguments are passed in R0-R7, which matches Go ABIInternal for the first eight arguments.
// R9 is used as a temporary register.
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $0-0
MOVD ·x_cgo_init_call(SB), R9
MOVD (R9), R9
CALL R9
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $0-0
MOVD ·x_cgo_thread_start_call(SB), R9
MOVD (R9), R9
CALL R9
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $0-0
MOVD ·x_cgo_setenv_call(SB), R9
MOVD (R9), R9
CALL R9
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $0-0
MOVD ·x_cgo_unsetenv_call(SB), R9
MOVD (R9), R9
CALL R9
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0
CALL ·x_cgo_notify_runtime_init_done(SB)
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_bindm(SB)
RET
// func setg_trampoline(setg uintptr, g uintptr)
TEXT ·setg_trampoline(SB), NOSPLIT, $0-16
MOVD G+8(FP), R0
MOVD setg+0(FP), R9
CALL R9
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $0-0
// See crosscall2.
SUB $(8*24), RSP
STP (R0, R1), (8*1)(RSP)
MOVD R3, (8*3)(RSP)
SAVE_R19_TO_R28(8*4)
SAVE_F8_TO_F15(8*14)
STP (R29, R30), (8*22)(RSP)
MOVD ·threadentry_call(SB), R9
MOVD (R9), R9
CALL R9
MOVD $0, R0 // TODO: get the return value from threadentry
RESTORE_R19_TO_R28(8*4)
RESTORE_F8_TO_F15(8*14)
LDP (8*22)(RSP), (R29, R30)
ADD $(8*24), RSP
RET
TEXT ·call5(SB), NOSPLIT, $0-0
MOVD fn+0(FP), R9
MOVD a1+8(FP), R0
MOVD a2+16(FP), R1
MOVD a3+24(FP), R2
MOVD a4+32(FP), R3
MOVD a5+40(FP), R4
CALL R9
MOVD R0, ret+48(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_loong64.s 0000664 0000000 0000000 00000003464 15207302613 0027240 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build !cgo && linux
#include "textflag.h"
#include "go_asm.h"
#include "abi_loong64.h"
// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions.
// R23 is used as temporary register.
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16
MOVV R4, 8(R3)
MOVV R5, 16(R3)
MOVV ·x_cgo_init_call(SB), R23
MOVV (R23), R23
CALL (R23)
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8
MOVV R4, 8(R3)
MOVV ·x_cgo_thread_start_call(SB), R23
MOVV (R23), R23
CALL (R23)
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8
MOVV R4, 8(R3)
MOVV ·x_cgo_setenv_call(SB), R23
MOVV (R23), R23
CALL (R23)
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8
MOVV R4, 8(R3)
MOVV ·x_cgo_unsetenv_call(SB), R23
MOVV (R23), R23
CALL (R23)
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_notify_runtime_init_done(SB)
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_bindm(SB)
RET
// func setg_trampoline(setg uintptr, g uintptr)
TEXT ·setg_trampoline(SB), NOSPLIT, $0
MOVV G+8(FP), R4
MOVV setg+0(FP), R23
CALL (R23)
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $0
// See crosscall2.
ADDV $(-23*8), R3
MOVV R4, (1*8)(R3) // fn unsafe.Pointer
MOVV R5, (2*8)(R3) // a unsafe.Pointer
MOVV R7, (3*8)(R3) // ctxt uintptr
SAVE_R22_TO_R31((4*8))
SAVE_F24_TO_F31((14*8))
MOVV R1, (22*8)(R3)
MOVV ·threadentry_call(SB), R23
MOVV (R23), R23
CALL (R23)
RESTORE_R22_TO_R31((4*8))
RESTORE_F24_TO_F31((14*8))
MOVV (22*8)(R3), R1
ADDV $(23*8), R3
RET
TEXT ·call5(SB), NOSPLIT, $0-0
MOVV fn+0(FP), R23
MOVV a1+8(FP), R4
MOVV a2+16(FP), R5
MOVV a3+24(FP), R6
MOVV a4+32(FP), R7
MOVV a5+40(FP), R8
CALL (R23)
MOVV R4, ret+48(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_ppc64le.s 0000664 0000000 0000000 00000011134 15207302613 0027216 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build !cgo && linux
#include "textflag.h"
#include "go_asm.h"
// These trampolines map the C ABI to Go ABI and call into the Go equivalent functions.
//
// PPC64LE ELFv2 ABI stack frame layout:
// 0(R1) = backchain (pointer to caller's frame)
// 8(R1) = CR save area
// 16(R1) = LR save area
// 24(R1) = reserved
// 32(R1) = parameter save area (minimum 64 bytes for 8 args)
//
// Two patterns are used depending on call direction:
//
// C→Go trampolines: The C caller already provides a 32-byte linkage area.
// Save LR/CR into caller's frame at 16(R1)/8(R1) BEFORE allocating,
// then use MOVDU to allocate and set backchain atomically.
//
// Go→C trampolines: Go callers don't provide ELFv2 linkage area.
// Allocate frame first with MOVDU, then save LR/CR into OUR frame.
TEXT x_cgo_init_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
// R3, R4 already have the arguments
MOVD ·x_cgo_init_call(SB), R12
MOVD (R12), R12
MOVD R12, CTR
CALL CTR
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
MOVD ·x_cgo_thread_start_call(SB), R12
MOVD (R12), R12
MOVD R12, CTR
CALL CTR
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
// void (*_cgo_setenv)(char**)
// C arg: R3 = pointer to env
// This is C→Go: caller is C ABI.
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
MOVD ·x_cgo_setenv_call(SB), R12
MOVD (R12), R12
MOVD R12, CTR
CALL CTR
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
MOVD ·x_cgo_unsetenv_call(SB), R12
MOVD (R12), R12
MOVD R12, CTR
CALL CTR
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
CALL ·x_cgo_notify_runtime_init_done(SB)
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
CALL ·x_cgo_bindm(SB)
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT ·setg_trampoline(SB), NOSPLIT|NOFRAME, $0-16
// Save LR, CR, and R31 to non-volatile registers (C ABI preserves R14-R31)
MOVD LR, R20
MOVW CR, R21
MOVD R31, R22 // save R31 because load_g clobbers it
// Load arguments from Go stack
MOVD 32(R1), R12 // setg function pointer
MOVD 40(R1), R3 // g pointer → first C arg
// Allocate ELFv2 frame for the C callee (32 bytes minimum)
MOVDU R1, -32(R1)
// Call setg_gcc which stores g to TLS
MOVD R12, CTR
CALL CTR
// setg_gcc stored g to TLS but restored old g in R30.
// Call load_g to reload g from TLS into R30.
// Note: load_g clobbers R31
CALL runtime·load_g(SB)
// Deallocate frame
ADD $32, R1
// Clear R0 before returning to Go code.
// Go uses R0 as a constant 0 for things like "std r0,X(r1)" to zero stack locations.
// C/assembly functions may leave garbage in R0.
XOR R0, R0, R0
// Restore LR, CR, and R31 from non-volatile registers
MOVD R22, R31 // restore R31
MOVD R20, LR
MOVW R21, CR
RET
TEXT threadentry_trampoline(SB), NOSPLIT|NOFRAME, $0-0
MOVD LR, 16(R1)
MOVW CR, R0
MOVD R0, 8(R1)
MOVDU R1, -32(R1)
MOVD ·threadentry_call(SB), R12
MOVD (R12), R12
MOVD R12, CTR
CALL CTR
ADD $32, R1
MOVD 16(R1), LR
MOVD 8(R1), R0
MOVW R0, CR
RET
TEXT ·call5(SB), NOSPLIT|NOFRAME, $0-56
MOVD LR, R20
MOVW CR, R21
// Load arguments from Go stack into C argument registers
// Go placed args at 32(R1), 40(R1), etc.
MOVD 32(R1), R12 // fn
MOVD 40(R1), R3 // a1 → first C arg
MOVD 48(R1), R4 // a2 → second C arg
MOVD 56(R1), R5 // a3 → third C arg
MOVD 64(R1), R6 // a4 → fourth C arg
MOVD 72(R1), R7 // a5 → fifth C arg
MOVDU R1, -32(R1)
MOVD R12, CTR
CALL CTR
// Store return value
// After MOVDU -32, original 80(R1) is now at 80+32=112(R1)
MOVD R3, (80+32)(R1)
// Deallocate frame
ADD $32, R1
// Clear R0 before returning to Go code.
// Go uses R0 as a constant 0 register for things like "std r0,X(r1)"
// to zero stack locations. C functions may leave garbage in R0.
XOR R0, R0, R0
// Restore LR/CR from non-volatile registers
MOVD R20, LR
MOVW R21, CR
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/trampolines_riscv64.s 0000664 0000000 0000000 00000002720 15207302613 0027242 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build !cgo && linux
#include "textflag.h"
#include "go_asm.h"
// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions.
// X5 is used as temporary register.
TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16
MOV X10, 8(SP)
MOV X11, 16(SP)
MOV ·x_cgo_init_call(SB), X5
MOV (X5), X5
CALL X5
RET
TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8
MOV X10, 8(SP)
MOV ·x_cgo_thread_start_call(SB), X5
MOV (X5), X5
CALL X5
RET
TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8
MOV X10, 8(SP)
MOV ·x_cgo_setenv_call(SB), X5
MOV (X5), X5
CALL X5
RET
TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8
MOV X10, 8(SP)
MOV ·x_cgo_unsetenv_call(SB), X5
MOV (X5), X5
CALL X5
RET
TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_notify_runtime_init_done(SB)
RET
TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0
CALL ·x_cgo_bindm(SB)
RET
// func setg_trampoline(setg uintptr, g uintptr)
TEXT ·setg_trampoline(SB), NOSPLIT, $0
MOV gp+8(FP), X10
MOV setg+0(FP), X5
CALL X5
RET
TEXT threadentry_trampoline(SB), NOSPLIT, $16
MOV X10, 8(SP)
MOV ·threadentry_call(SB), X5
MOV (X5), X5
CALL X5
RET
TEXT ·call5(SB), NOSPLIT, $0-48
MOV fn+0(FP), X5
MOV a1+8(FP), X10
MOV a2+16(FP), X11
MOV a3+24(FP), X12
MOV a4+32(FP), X13
MOV a5+40(FP), X14
CALL X5
MOV X10, ret+48(FP)
RET
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/zsymbols.go 0000664 0000000 0000000 00000011467 15207302613 0025362 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package fakecgo
import (
"syscall"
"unsafe"
)
//go:nosplit
//go:norace
func malloc(size uintptr) unsafe.Pointer {
ret := call5(mallocABI0, uintptr(size), 0, 0, 0, 0)
// this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer
return *(*unsafe.Pointer)(unsafe.Pointer(&ret))
}
//go:nosplit
//go:norace
func free(ptr unsafe.Pointer) {
call5(freeABI0, uintptr(ptr), 0, 0, 0, 0)
}
//go:nosplit
//go:norace
func setenv(name *byte, value *byte, overwrite int32) int32 {
return int32(call5(setenvABI0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), uintptr(overwrite), 0, 0))
}
//go:nosplit
//go:norace
func unsetenv(name *byte) int32 {
return int32(call5(unsetenvABI0, uintptr(unsafe.Pointer(name)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func sigfillset(set *sigset_t) int32 {
return int32(call5(sigfillsetABI0, uintptr(unsafe.Pointer(set)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func nanosleep(ts *syscall.Timespec, rem *syscall.Timespec) int32 {
return int32(call5(nanosleepABI0, uintptr(unsafe.Pointer(ts)), uintptr(unsafe.Pointer(rem)), 0, 0, 0))
}
//go:nosplit
//go:norace
func abort() {
call5(abortABI0, 0, 0, 0, 0, 0)
}
//go:nosplit
//go:norace
func pthread_attr_init(attr *pthread_attr_t) int32 {
return int32(call5(pthread_attr_initABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_create(thread *pthread_t, attr *pthread_attr_t, start unsafe.Pointer, arg unsafe.Pointer) int32 {
return int32(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(start), uintptr(arg), 0))
}
//go:nosplit
//go:norace
func pthread_detach(thread pthread_t) int32 {
return int32(call5(pthread_detachABI0, uintptr(thread), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_sigmask(how sighow, ign *sigset_t, oset *sigset_t) int32 {
return int32(call5(pthread_sigmaskABI0, uintptr(how), uintptr(unsafe.Pointer(ign)), uintptr(unsafe.Pointer(oset)), 0, 0))
}
//go:nosplit
//go:norace
func pthread_mutex_lock(mutex *pthread_mutex_t) int32 {
return int32(call5(pthread_mutex_lockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_mutex_unlock(mutex *pthread_mutex_t) int32 {
return int32(call5(pthread_mutex_unlockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_cond_broadcast(cond *pthread_cond_t) int32 {
return int32(call5(pthread_cond_broadcastABI0, uintptr(unsafe.Pointer(cond)), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_setspecific(key pthread_key_t, value unsafe.Pointer) int32 {
return int32(call5(pthread_setspecificABI0, uintptr(key), uintptr(value), 0, 0, 0))
}
//go:linkname _malloc _malloc
var _malloc uint8
var mallocABI0 = uintptr(unsafe.Pointer(&_malloc))
//go:linkname _free _free
var _free uint8
var freeABI0 = uintptr(unsafe.Pointer(&_free))
//go:linkname _setenv _setenv
var _setenv uint8
var setenvABI0 = uintptr(unsafe.Pointer(&_setenv))
//go:linkname _unsetenv _unsetenv
var _unsetenv uint8
var unsetenvABI0 = uintptr(unsafe.Pointer(&_unsetenv))
//go:linkname _sigfillset _sigfillset
var _sigfillset uint8
var sigfillsetABI0 = uintptr(unsafe.Pointer(&_sigfillset))
//go:linkname _nanosleep _nanosleep
var _nanosleep uint8
var nanosleepABI0 = uintptr(unsafe.Pointer(&_nanosleep))
//go:linkname _abort _abort
var _abort uint8
var abortABI0 = uintptr(unsafe.Pointer(&_abort))
//go:linkname _pthread_attr_init _pthread_attr_init
var _pthread_attr_init uint8
var pthread_attr_initABI0 = uintptr(unsafe.Pointer(&_pthread_attr_init))
//go:linkname _pthread_create _pthread_create
var _pthread_create uint8
var pthread_createABI0 = uintptr(unsafe.Pointer(&_pthread_create))
//go:linkname _pthread_detach _pthread_detach
var _pthread_detach uint8
var pthread_detachABI0 = uintptr(unsafe.Pointer(&_pthread_detach))
//go:linkname _pthread_sigmask _pthread_sigmask
var _pthread_sigmask uint8
var pthread_sigmaskABI0 = uintptr(unsafe.Pointer(&_pthread_sigmask))
//go:linkname _pthread_mutex_lock _pthread_mutex_lock
var _pthread_mutex_lock uint8
var pthread_mutex_lockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_lock))
//go:linkname _pthread_mutex_unlock _pthread_mutex_unlock
var _pthread_mutex_unlock uint8
var pthread_mutex_unlockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_unlock))
//go:linkname _pthread_cond_broadcast _pthread_cond_broadcast
var _pthread_cond_broadcast uint8
var pthread_cond_broadcastABI0 = uintptr(unsafe.Pointer(&_pthread_cond_broadcast))
//go:linkname _pthread_setspecific _pthread_setspecific
var _pthread_setspecific uint8
var pthread_setspecificABI0 = uintptr(unsafe.Pointer(&_pthread_setspecific))
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/zsymbols_darwin.go 0000664 0000000 0000000 00000005414 15207302613 0026721 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
import "unsafe"
//go:cgo_import_dynamic purego_malloc malloc "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_free free "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_setenv setenv "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_unsetenv unsetenv "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_sigfillset sigfillset "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_nanosleep nanosleep "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_abort abort "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_create pthread_create "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_detach pthread_detach "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_self pthread_self "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "/usr/lib/libSystem.B.dylib"
//go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "/usr/lib/libSystem.B.dylib"
//go:nosplit
//go:norace
func pthread_self() pthread_t {
return pthread_t(call5(pthread_selfABI0, 0, 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_get_stacksize_np(thread pthread_t) size_t {
return size_t(call5(pthread_get_stacksize_npABI0, uintptr(thread), 0, 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_attr_setstacksize(attr *pthread_attr_t, size size_t) int32 {
return int32(call5(pthread_attr_setstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(size), 0, 0, 0))
}
//go:linkname _pthread_self _pthread_self
var _pthread_self uint8
var pthread_selfABI0 = uintptr(unsafe.Pointer(&_pthread_self))
//go:linkname _pthread_get_stacksize_np _pthread_get_stacksize_np
var _pthread_get_stacksize_np uint8
var pthread_get_stacksize_npABI0 = uintptr(unsafe.Pointer(&_pthread_get_stacksize_np))
//go:linkname _pthread_attr_setstacksize _pthread_attr_setstacksize
var _pthread_attr_setstacksize uint8
var pthread_attr_setstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_setstacksize))
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/zsymbols_freebsd.go 0000664 0000000 0000000 00000004314 15207302613 0027045 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
import "unsafe"
//go:cgo_import_dynamic purego_malloc malloc "libc.so.7"
//go:cgo_import_dynamic purego_free free "libc.so.7"
//go:cgo_import_dynamic purego_setenv setenv "libc.so.7"
//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.7"
//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.7"
//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.7"
//go:cgo_import_dynamic purego_abort abort "libc.so.7"
//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so"
//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so"
//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so"
//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so"
//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so"
//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so"
//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so"
//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so"
//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so"
//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so"
//go:nosplit
//go:norace
func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 {
return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_attr_destroy(attr *pthread_attr_t) int32 {
return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
}
//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize
var _pthread_attr_getstacksize uint8
var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize))
//go:linkname _pthread_attr_destroy _pthread_attr_destroy
var _pthread_attr_destroy uint8
var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy))
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/zsymbols_linux.go 0000664 0000000 0000000 00000004340 15207302613 0026571 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
import "unsafe"
//go:cgo_import_dynamic purego_malloc malloc "libc.so.6"
//go:cgo_import_dynamic purego_free free "libc.so.6"
//go:cgo_import_dynamic purego_setenv setenv "libc.so.6"
//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.6"
//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.6"
//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.6"
//go:cgo_import_dynamic purego_abort abort "libc.so.6"
//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so.0"
//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so.0"
//go:nosplit
//go:norace
func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 {
return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_attr_destroy(attr *pthread_attr_t) int32 {
return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
}
//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize
var _pthread_attr_getstacksize uint8
var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize))
//go:linkname _pthread_attr_destroy _pthread_attr_destroy
var _pthread_attr_destroy uint8
var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy))
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/zsymbols_netbsd.go 0000664 0000000 0000000 00000005074 15207302613 0026716 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package fakecgo
import "unsafe"
//go:cgo_import_dynamic purego_malloc malloc "libc.so"
//go:cgo_import_dynamic purego_free free "libc.so"
//go:cgo_import_dynamic purego_setenv setenv "libc.so"
//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so"
//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so"
//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so"
//go:cgo_import_dynamic purego_abort abort "libc.so"
//go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so"
//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so"
//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so"
//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so"
//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so"
//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so"
//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so"
//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so"
//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so"
//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so"
//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so"
//go:nosplit
//go:norace
func sigaltstack(ss *stack_t, old_ss *stack_t) int32 {
return int32(call5(sigaltstackABI0, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(old_ss)), 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 {
return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0))
}
//go:nosplit
//go:norace
func pthread_attr_destroy(attr *pthread_attr_t) int32 {
return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
}
//go:linkname _sigaltstack _sigaltstack
var _sigaltstack uint8
var sigaltstackABI0 = uintptr(unsafe.Pointer(&_sigaltstack))
//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize
var _pthread_attr_getstacksize uint8
var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize))
//go:linkname _pthread_attr_destroy _pthread_attr_destroy
var _pthread_attr_destroy uint8
var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy))
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ztrampolines_darwin.s 0000664 0000000 0000000 00000001066 15207302613 0027422 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
TEXT _pthread_self(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_self(SB)
TEXT _pthread_get_stacksize_np(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_get_stacksize_np(SB)
TEXT _pthread_attr_setstacksize(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_setstacksize(SB)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ztrampolines_freebsd.s 0000664 0000000 0000000 00000000742 15207302613 0027550 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_getstacksize(SB)
TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_destroy(SB)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ztrampolines_linux.s 0000664 0000000 0000000 00000000742 15207302613 0027275 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_getstacksize(SB)
TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_destroy(SB)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ztrampolines_netbsd.s 0000664 0000000 0000000 00000001054 15207302613 0027412 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
TEXT _sigaltstack(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_sigaltstack(SB)
TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_getstacksize(SB)
TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_destroy(SB)
golang-github-ebitengine-purego-0.10.1/internal/fakecgo/ztrampolines_stubs.s 0000664 0000000 0000000 00000002714 15207302613 0027277 0 ustar 00root root 0000000 0000000 // Code generated by 'go generate' with gen.go. DO NOT EDIT.
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
#include "textflag.h"
// these stubs are here because it is not possible to go:linkname directly the C functions
TEXT _malloc(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_malloc(SB)
TEXT _free(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_free(SB)
TEXT _setenv(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_setenv(SB)
TEXT _unsetenv(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_unsetenv(SB)
TEXT _sigfillset(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_sigfillset(SB)
TEXT _nanosleep(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_nanosleep(SB)
TEXT _abort(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_abort(SB)
TEXT _pthread_attr_init(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_attr_init(SB)
TEXT _pthread_create(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_create(SB)
TEXT _pthread_detach(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_detach(SB)
TEXT _pthread_sigmask(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_sigmask(SB)
TEXT _pthread_mutex_lock(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_mutex_lock(SB)
TEXT _pthread_mutex_unlock(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_mutex_unlock(SB)
TEXT _pthread_cond_broadcast(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_cond_broadcast(SB)
TEXT _pthread_setspecific(SB), NOSPLIT|NOFRAME, $0-0
JMP purego_pthread_setspecific(SB)
golang-github-ebitengine-purego-0.10.1/internal/load/ 0000775 0000000 0000000 00000000000 15207302613 0022460 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/load/load_unix.go 0000664 0000000 0000000 00000000744 15207302613 0024776 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd
package load
import "github.com/ebitengine/purego"
func OpenLibrary(name string) (uintptr, error) {
return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL)
}
func CloseLibrary(handle uintptr) error {
return purego.Dlclose(handle)
}
func OpenSymbol(lib uintptr, name string) (uintptr, error) {
return purego.Dlsym(lib, name)
}
golang-github-ebitengine-purego-0.10.1/internal/load/load_windows.go 0000664 0000000 0000000 00000000731 15207302613 0025501 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package load
import (
"syscall"
)
func OpenLibrary(name string) (uintptr, error) {
handle, err := syscall.LoadLibrary(name)
return uintptr(handle), err
}
func CloseLibrary(handle uintptr) error {
return syscall.FreeLibrary(syscall.Handle(handle))
}
func OpenSymbol(lib uintptr, name string) (uintptr, error) {
return syscall.GetProcAddress(syscall.Handle(lib), name)
}
golang-github-ebitengine-purego-0.10.1/internal/strings/ 0000775 0000000 0000000 00000000000 15207302613 0023232 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/strings/strings.go 0000664 0000000 0000000 00000001751 15207302613 0025256 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
package strings
import (
"unsafe"
)
// hasSuffix tests whether the string s ends with suffix.
func hasSuffix(s, suffix string) bool {
return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}
// CString converts a go string to *byte that can be passed to C code.
func CString(name string) *byte {
if hasSuffix(name, "\x00") {
return &(*(*[]byte)(unsafe.Pointer(&name)))[0]
}
b := make([]byte, len(name)+1)
copy(b, name)
return &b[0]
}
// GoString copies a null-terminated char* to a Go string.
func GoString(c uintptr) string {
// We take the address and then dereference it to trick go vet from creating a possible misuse of unsafe.Pointer
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&c))
if ptr == nil {
return ""
}
var length int
for {
if *(*byte)(unsafe.Add(ptr, uintptr(length))) == '\x00' {
break
}
length++
}
return string(unsafe.Slice((*byte)(ptr), length))
}
golang-github-ebitengine-purego-0.10.1/internal/xreflect/ 0000775 0000000 0000000 00000000000 15207302613 0023355 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/internal/xreflect/reflect_go124.go 0000664 0000000 0000000 00000000530 15207302613 0026242 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build !go1.25
package xreflect
import "reflect"
// TODO: remove this and use Go 1.25's reflect.TypeAssert when minimum go.mod version is 1.25
func TypeAssert[T any](v reflect.Value) (T, bool) {
v2, ok := v.Interface().(T)
return v2, ok
}
golang-github-ebitengine-purego-0.10.1/internal/xreflect/reflect_go125.go 0000664 0000000 0000000 00000000355 15207302613 0026250 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build go1.25
package xreflect
import "reflect"
func TypeAssert[T any](v reflect.Value) (T, bool) {
return reflect.TypeAssert[T](v)
}
golang-github-ebitengine-purego-0.10.1/is_ios.go 0000664 0000000 0000000 00000000575 15207302613 0021550 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo
package purego
// if you are getting this error it means that you have
// CGO_ENABLED=0 while trying to build for ios.
// purego does not support this mode yet.
// the fix is to set CGO_ENABLED=1 which will require
// a C compiler.
var _ = _PUREGO_REQUIRES_CGO_ON_IOS
golang-github-ebitengine-purego-0.10.1/nocgo.go 0000664 0000000 0000000 00000002405 15207302613 0021362 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !cgo && (darwin || freebsd || linux || netbsd)
package purego
// if CGO_ENABLED=0 import fakecgo to setup the Cgo runtime correctly.
// This is required since some frameworks need TLS setup the C way which Go doesn't do.
// We currently don't support ios in fakecgo mode so force Cgo or fail
//
// The way that the Cgo runtime (runtime/cgo) works is by setting some variables found
// in runtime with non-null GCC compiled functions. The variables that are replaced are
// var (
// iscgo bool // in runtime/cgo.go
// _cgo_init unsafe.Pointer // in runtime/cgo.go
// _cgo_thread_start unsafe.Pointer // in runtime/cgo.go
// _cgo_notify_runtime_init_done unsafe.Pointer // in runtime/cgo.go
// _cgo_setenv unsafe.Pointer // in runtime/env_posix.go
// _cgo_unsetenv unsafe.Pointer // in runtime/env_posix.go
// )
// importing fakecgo will set these (using //go:linkname) with functions written
// entirely in Go (except for some assembly trampolines to change GCC ABI to Go ABI).
// Doing so makes it possible to build applications that call into C without CGO_ENABLED=1.
import _ "github.com/ebitengine/purego/internal/fakecgo"
golang-github-ebitengine-purego-0.10.1/objc/ 0000775 0000000 0000000 00000000000 15207302613 0020642 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/objc/objc_block_darwin.go 0000664 0000000 0000000 00000021737 15207302613 0024636 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package objc
import (
"fmt"
"reflect"
"sync"
"unsafe"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/internal/xreflect"
)
const (
// The end-goal of these defaults is to get an Objective-C memory-managed block object
// that won't try to free() a Go pointer, but will call our custom blockFunctionCache.Delete()
// when the reference count drops to zero, so the associated function is also unreferenced.
// blockBaseClass is the name of the class that block objects will be initialized with.
blockBaseClass = "__NSMallocBlock__"
// blockFlags is the set of flags that block objects will be initialized with.
blockFlags = blockHasCopyDispose | blockHasSignature
// blockHasCopyDispose is a flag that tells the Objective-C runtime the block exports Copy and/or Dispose helpers.
blockHasCopyDispose = 1 << 25
// blockHasSignature is a flag that tells the Objective-C runtime the block exports a function signature.
blockHasSignature = 1 << 30
)
// blockDescriptor is the Go representation of an Objective-C block descriptor.
// It is a component to be referenced by blockDescriptor.
//
// The layout of this struct matches Block_literal_1 described in https://clang.llvm.org/docs/Block-ABI-Apple.html#high-level
type blockDescriptor struct {
_ uintptr
size uintptr
_ uintptr
dispose uintptr
signature *uint8
}
// blockLayout is the Go representation of the structure abstracted by a block pointer.
// From the Objective-C point of view, a pointer to this struct is equivalent to an ID that
// references a block.
//
// The layout of this struct matches __block_literal_1 described in https://clang.llvm.org/docs/Block-ABI-Apple.html#high-level
type blockLayout struct {
isa Class
flags uint32
_ uint32
invoke uintptr
descriptor *blockDescriptor
}
// blockFunctionCache is a thread safe cache of block layouts.
//
// The function closures themselves are kept alive by caching them internally until the Objective-C runtime indicates that
// they can be released (presumably when the reference count reaches zero). This approach is used instead of appending the function
// object to the block allocation, where it is out of the visible domain of Go's GC.
type blockFunctionCache struct {
mutex sync.RWMutex
functions map[Block]reflect.Value
}
// Load retrieves a function (in the form of a reflect.Value, so Call can be invoked) associated with the key Block.
func (b *blockFunctionCache) Load(key Block) reflect.Value {
b.mutex.RLock()
defer b.mutex.RUnlock()
return b.functions[key]
}
// Store associates a function (in the form of a reflect.Value) with the key Block.
func (b *blockFunctionCache) Store(key Block, value reflect.Value) Block {
b.mutex.Lock()
defer b.mutex.Unlock()
b.functions[key] = value
return key
}
// Delete removed the function associated with the key Block.
func (b *blockFunctionCache) Delete(key Block) {
b.mutex.Lock()
defer b.mutex.Unlock()
delete(b.functions, key)
}
// newBlockFunctionCache initializes a new blockFunctionCache
func newBlockFunctionCache() *blockFunctionCache {
return &blockFunctionCache{functions: map[Block]reflect.Value{}}
}
// blockCache is a thread safe cache of block layouts.
//
// It takes advantage of the block being the first argument of a block call being the block closure,
// only invoking [github.com/ebitengine/purego.NewCallback] when it encounters a new function type (rather than on for every block creation).
// This should mitigate block creations putting pressure on the callback limit.
type blockCache struct {
sync.Mutex
descriptorTemplate blockDescriptor
layoutTemplate blockLayout
layouts map[reflect.Type]blockLayout
Functions *blockFunctionCache
}
// encode returns a blocks type as if it was given to @encode(typ)
func (*blockCache) encode(typ reflect.Type) *uint8 {
// this algorithm was copied from encodeFunc,
// but altered to panic on error, and to only accept a block-type signature.
if typ == nil || typ.Kind() != reflect.Func {
panic("objc: not a function")
}
var encoding string
switch typ.NumOut() {
case 0:
encoding = encVoid
default:
returnType, err := encodeType(typ.Out(0), false)
if err != nil {
panic(fmt.Sprintf("objc: %v", err))
}
encoding = returnType
}
if typ.NumIn() == 0 || typ.In(0) != reflect.TypeOf(Block(0)) {
panic(fmt.Sprintf("objc: A Block implementation must take a Block as its first argument; got %v", typ.String()))
}
encoding += encId
for i := 1; i < typ.NumIn(); i++ {
argType, err := encodeType(typ.In(i), false)
if err != nil {
panic(fmt.Sprintf("objc: %v", err))
}
encoding = fmt.Sprint(encoding, argType)
}
// return the encoding as a C-style string.
return &append([]uint8(encoding), 0)[0]
}
// getLayout retrieves a blockLayout VALUE constructed with the supplied function type.
// It will panic if the type is not a valid block function.
func (b *blockCache) getLayout(typ reflect.Type) blockLayout {
b.Lock()
defer b.Unlock()
// return the cached layout, if it exists.
if layout, ok := b.layouts[typ]; ok {
return layout
}
// otherwise: create a layout, and populate it with the default templates
layout := b.layoutTemplate
layout.descriptor = &blockDescriptor{}
*layout.descriptor = b.descriptorTemplate
// getting the signature now will panic on invalid types before we invest in creating a callback.
layout.descriptor.signature = b.encode(typ)
// create a global callback.
// this single callback can dispatch to any function with the same signature,
// since the user-provided functions are associated with the actual block allocations.
layout.invoke = purego.NewCallback(
reflect.MakeFunc(
typ,
func(args []reflect.Value) (results []reflect.Value) {
block, ok := xreflect.TypeAssert[Block](args[0])
if !ok {
panic(fmt.Sprintf("objc: block argument is not a block but %s", args[0].Type().String()))
}
return b.Functions.Load(block).Call(args)
},
).Interface(),
)
// store it and return it
b.layouts[typ] = layout
return layout
}
// newBlockCache initializes a block cache.
// It should not be called until AFTER libobjc is fully initialized.
func newBlockCache() *blockCache {
cache := &blockCache{
descriptorTemplate: blockDescriptor{
size: unsafe.Sizeof(blockLayout{}),
},
layoutTemplate: blockLayout{
isa: GetClass(blockBaseClass),
flags: blockFlags,
},
layouts: map[reflect.Type]blockLayout{},
Functions: newBlockFunctionCache(),
}
cache.descriptorTemplate.dispose = purego.NewCallback(cache.Functions.Delete)
return cache
}
// theBlocksCache is the global block cache
var theBlocksCache *blockCache
// Block is an opaque pointer to an Objective-C object containing a function with its associated closure.
type Block ID
// Copy creates a copy of a block on the Objective-C heap (or increments the reference count if already on the heap).
// Use [Block.Release] to free the copy when it is no longer in use.
func (b Block) Copy() Block {
return _Block_copy(b)
}
// Invoke calls the implementation of a block.
func (b Block) Invoke(args ...any) {
fn := theBlocksCache.Functions.Load(b)
reflectedArgs := make([]reflect.Value, len(args)+1)
reflectedArgs[0] = reflect.ValueOf(b)
for i := range args {
reflectedArgs[i+1] = reflect.ValueOf(args[i])
}
fn.Call(reflectedArgs)
}
// Release decrements the Block's reference count, and if it is the last reference, frees it.
func (b Block) Release() {
_Block_release(b)
}
// NewBlock takes a Go function that takes a Block as its first argument.
// It returns an Block that can be called by Objective-C code.
// The function panics if an error occurs.
// Use [Block.Release] to free this block when it is no longer in use.
func NewBlock(fn any) Block {
// get or create a block layout for the callback.
layout := theBlocksCache.getLayout(reflect.TypeOf(fn))
// we created the layout in Go memory, so we'll copy it to a newly-created Objective-C object.
block := Block(unsafe.Pointer(&layout)).Copy()
// associate the fn with the block we created before returning it.
return theBlocksCache.Functions.Store(block, reflect.ValueOf(fn))
}
// InvokeBlock is a convenience method for calling the implementation of a block.
// The block implementation must return 1 value.
func InvokeBlock[T any](block Block, args ...any) (result T, err error) {
block = block.Copy()
defer block.Release()
fn := theBlocksCache.Functions.Load(block)
if fn.Type().NumIn() != len(args)+1 {
return result, fmt.Errorf("objc: block callback expects %d arguments, got %d", fn.Type().NumIn()-1, len(args))
}
reflectedArgs := make([]reflect.Value, len(args)+1)
reflectedArgs[0] = reflect.ValueOf(block)
for i := range args {
reflectedArgs[i+1] = reflect.ValueOf(args[i])
}
callResult := fn.Call(reflectedArgs)
var ok bool
result, ok = xreflect.TypeAssert[T](callResult[0])
if !ok {
return result, fmt.Errorf("objc: the returned value type %s was not %T", callResult[0].Type().String(), result)
}
return result, nil
}
golang-github-ebitengine-purego-0.10.1/objc/objc_block_darwin_test.go 0000664 0000000 0000000 00000006626 15207302613 0025675 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package objc_test
import (
"fmt"
"testing"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/objc"
)
func ExampleNewBlock() {
_, err := purego.Dlopen("/System/Library/Frameworks/Foundation.framework/Foundation", purego.RTLD_GLOBAL|purego.RTLD_NOW)
if err != nil {
panic(err)
}
var count = 0
block := objc.NewBlock(
func(block objc.Block, line objc.ID, stop *bool) {
count++
fmt.Printf("LINE %d: %s\n", count, objc.Send[string](line, objc.RegisterName("UTF8String")))
*stop = count == 3
},
)
defer block.Release()
lines := objc.ID(objc.GetClass("NSString")).Send(objc.RegisterName("stringWithUTF8String:"), "Alpha\nBeta\nGamma\nDelta\nEpsilon")
defer lines.Send(objc.RegisterName("release"))
lines.Send(objc.RegisterName("enumerateLinesUsingBlock:"), block)
// Output:
// LINE 1: Alpha
// LINE 2: Beta
// LINE 3: Gamma
}
func ExampleInvokeBlock() {
type vector struct {
X, Y, Z float64
}
block := objc.NewBlock(
func(block objc.Block, v1, v2 *vector) *vector {
return &vector{
X: v1.Y*v2.Z - v1.Z*v2.Y,
Y: v1.Z*v2.X - v1.X*v2.Z,
Z: v1.X*v2.Y - v1.Y*v2.X,
}
},
)
defer block.Release()
result, err := objc.InvokeBlock[*vector](
block,
&vector{X: 0.1, Y: 2.3, Z: 4.5},
&vector{X: 6.7, Y: 8.9, Z: 0.1},
)
fmt.Println(*result, err)
// Output: {-39.82 30.14 -14.52}
}
func TestInvoke(t *testing.T) {
t.Run("return an error when passing an invalid number of arguments", func(t *testing.T) {
block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 {
return a + b
})
defer block.Release()
if _, err := objc.InvokeBlock[int32](block, int32(8)); err == nil {
t.Fatal(err)
}
})
t.Run("return an error when passing an invalid return type", func(t *testing.T) {
block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 {
return a + b
})
defer block.Release()
if _, err := objc.InvokeBlock[string](block, int32(8), int32(2)); err == nil {
t.Fatal(err)
}
})
t.Run("add two int32's and returns the result", func(t *testing.T) {
block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 {
return a + b
})
defer block.Release()
result, err := objc.InvokeBlock[int32](block, int32(8), int32(2))
if err != nil {
t.Fatal(err)
}
if result != 10 {
t.Fatalf("expected 10, got %d", result)
}
})
t.Run("add two int32's and store the result in a variable", func(t *testing.T) {
var result int32
block := objc.NewBlock(func(_ objc.Block, a int32, b int32) {
result = a + b
})
defer block.Release()
block.Invoke(int32(8), int32(2))
if result != 10 {
t.Fatalf("expected 10, got %d", result)
}
})
}
func TestBlockCopyAndBlockRelease(t *testing.T) {
t.Parallel()
var refCount int
block := objc.NewBlock(
func(objc.Block) {
refCount++
},
)
defer block.Release()
refCount++
copies := make([]objc.Block, 17)
copies[0] = block
for index := 1; index < len(copies); index++ {
if refCount != index {
t.Fatalf("refCount: %d != %d", refCount, index)
}
copies[index] = copies[index-1].Copy()
if copies[index] != block {
t.Fatalf("Block.Copy(): %v != %v", copies[index], block)
}
copies[index].Invoke()
}
for _, copy := range copies[1:] {
copy.Release()
refCount--
}
refCount--
block.Invoke()
if refCount != 1 {
t.Fatalf("refCount: %d != 1", refCount)
}
}
golang-github-ebitengine-purego-0.10.1/objc/objc_runtime_darwin.go 0000664 0000000 0000000 00000063756 15207302613 0025236 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
// Package objc is a low-level pure Go objective-c runtime. This package is easy to use incorrectly, so it is best
// to use a wrapper that provides the functionality you need in a safer way.
package objc
import (
"errors"
"fmt"
"math"
"reflect"
"regexp"
"runtime"
"unicode"
"unsafe"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/internal/strings"
"github.com/ebitengine/purego/internal/xreflect"
)
// TODO: support try/catch?
// https://stackoverflow.com/questions/7062599/example-of-how-objective-cs-try-catch-implementation-is-executed-at-runtime
var (
objc_msgSend_fn uintptr
objc_msgSend_stret_fn uintptr
objc_msgSend func(obj ID, cmd SEL, args ...any) ID
objc_msgSendSuper2_fn uintptr
objc_msgSendSuper2_stret_fn uintptr
objc_msgSendSuper2 func(super *objc_super, cmd SEL, args ...any) ID
objc_getClass func(name string) Class
objc_getProtocol func(name string) *Protocol
objc_allocateProtocol func(name string) *Protocol
objc_registerProtocol func(protocol *Protocol)
objc_allocateClassPair func(super Class, name string, extraBytes uintptr) Class
objc_registerClassPair func(class Class)
sel_registerName func(name string) SEL
class_getSuperclass func(class Class) Class
class_getInstanceVariable func(class Class, name string) Ivar
class_getInstanceSize func(class Class) uintptr
class_addMethod func(class Class, name SEL, imp IMP, types string) bool
class_addIvar func(class Class, name string, size uintptr, alignment uint8, types string) bool
class_addProtocol func(class Class, protocol *Protocol) bool
ivar_getOffset func(ivar Ivar) uintptr
ivar_getName func(ivar Ivar) string
object_getClass func(obj ID) Class
object_getIvar func(obj ID, ivar Ivar) ID
object_setIvar func(obj ID, ivar Ivar, value ID)
protocol_getName func(protocol *Protocol) string
protocol_isEqual func(p *Protocol, p2 *Protocol) bool
protocol_addMethodDescription func(p *Protocol, name SEL, types string, isRequiredMethod bool, isInstanceMethod bool)
protocol_copyMethodDescriptionList func(p *Protocol, isRequiredMethod bool, isInstanceMethod bool, outCount *uint32) *MethodDescription
protocol_copyProtocolList func(p *Protocol, outCount *uint32) **Protocol
protocol_copyPropertyList2 func(p *Protocol, outCount *uint32, isRequiredProperty, isInstanceProperty bool) *Property
protocol_addProtocol func(p *Protocol, p2 *Protocol)
protocol_addProperty func(p *Protocol, name string, attributes []PropertyAttribute, attributeCount uint32, isRequiredProperty bool, isInstanceProperty bool)
property_getName func(p Property) string
property_getAttributes func(p Property) string
free func(ptr unsafe.Pointer)
_Block_copy func(Block) Block
_Block_release func(Block)
)
func init() {
objc, err := purego.Dlopen("/usr/lib/libobjc.A.dylib", purego.RTLD_GLOBAL|purego.RTLD_NOW)
if err != nil {
panic(fmt.Errorf("objc: %w", err))
}
objc_msgSend_fn, err = purego.Dlsym(objc, "objc_msgSend")
if err != nil {
panic(fmt.Errorf("objc: %w", err))
}
if runtime.GOARCH == "amd64" {
objc_msgSend_stret_fn, err = purego.Dlsym(objc, "objc_msgSend_stret")
if err != nil {
panic(fmt.Errorf("objc: %w", err))
}
objc_msgSendSuper2_stret_fn, err = purego.Dlsym(objc, "objc_msgSendSuper2_stret")
if err != nil {
panic(fmt.Errorf("objc: %w", err))
}
}
purego.RegisterFunc(&objc_msgSend, objc_msgSend_fn)
objc_msgSendSuper2_fn, err = purego.Dlsym(objc, "objc_msgSendSuper2")
if err != nil {
panic(fmt.Errorf("objc: %w", err))
}
purego.RegisterFunc(&objc_msgSendSuper2, objc_msgSendSuper2_fn)
purego.RegisterLibFunc(&object_getClass, objc, "object_getClass")
purego.RegisterLibFunc(&objc_getClass, objc, "objc_getClass")
purego.RegisterLibFunc(&objc_getProtocol, objc, "objc_getProtocol")
purego.RegisterLibFunc(&objc_allocateProtocol, objc, "objc_allocateProtocol")
purego.RegisterLibFunc(&objc_registerProtocol, objc, "objc_registerProtocol")
purego.RegisterLibFunc(&objc_allocateClassPair, objc, "objc_allocateClassPair")
purego.RegisterLibFunc(&objc_registerClassPair, objc, "objc_registerClassPair")
purego.RegisterLibFunc(&sel_registerName, objc, "sel_registerName")
purego.RegisterLibFunc(&class_getSuperclass, objc, "class_getSuperclass")
purego.RegisterLibFunc(&class_getInstanceVariable, objc, "class_getInstanceVariable")
purego.RegisterLibFunc(&class_addMethod, objc, "class_addMethod")
purego.RegisterLibFunc(&class_addIvar, objc, "class_addIvar")
purego.RegisterLibFunc(&class_addProtocol, objc, "class_addProtocol")
purego.RegisterLibFunc(&class_getInstanceSize, objc, "class_getInstanceSize")
purego.RegisterLibFunc(&ivar_getOffset, objc, "ivar_getOffset")
purego.RegisterLibFunc(&ivar_getName, objc, "ivar_getName")
purego.RegisterLibFunc(&protocol_getName, objc, "protocol_getName")
purego.RegisterLibFunc(&protocol_isEqual, objc, "protocol_isEqual")
purego.RegisterLibFunc(&protocol_addMethodDescription, objc, "protocol_addMethodDescription")
purego.RegisterLibFunc(&protocol_copyMethodDescriptionList, objc, "protocol_copyMethodDescriptionList")
purego.RegisterLibFunc(&protocol_copyProtocolList, objc, "protocol_copyProtocolList")
purego.RegisterLibFunc(&protocol_addProtocol, objc, "protocol_addProtocol")
purego.RegisterLibFunc(&protocol_addProperty, objc, "protocol_addProperty")
purego.RegisterLibFunc(&protocol_copyPropertyList2, objc, "protocol_copyPropertyList2")
purego.RegisterLibFunc(&property_getName, objc, "property_getName")
purego.RegisterLibFunc(&property_getAttributes, objc, "property_getAttributes")
purego.RegisterLibFunc(&object_getIvar, objc, "object_getIvar")
purego.RegisterLibFunc(&object_setIvar, objc, "object_setIvar")
purego.RegisterLibFunc(&free, purego.RTLD_DEFAULT, "free")
purego.RegisterLibFunc(&_Block_copy, objc, "_Block_copy")
purego.RegisterLibFunc(&_Block_release, objc, "_Block_release")
theBlocksCache = newBlockCache()
}
// ID is an opaque pointer to some Objective-C object
type ID uintptr
// Class returns the class of the object.
func (id ID) Class() Class {
return object_getClass(id)
}
// Send is a convenience method for sending messages to objects. This function takes a SEL
// instead of a string since RegisterName grabs the global Objective-C lock. It is best to cache the result
// of RegisterName.
func (id ID) Send(sel SEL, args ...any) ID {
return objc_msgSend(id, sel, args...)
}
// GetIvar reads the value of an instance variable in an object.
func (id ID) GetIvar(ivar Ivar) ID {
return object_getIvar(id, ivar)
}
// SetIvar sets the value of an instance variable in an object.
func (id ID) SetIvar(ivar Ivar, value ID) {
object_setIvar(id, ivar, value)
}
// keep in sync with func.go
const maxRegAllocStructSize = 16
// Send is a convenience method for sending messages to objects that can return any type.
// This function takes a SEL instead of a string since RegisterName grabs the global Objective-C lock.
// It is best to cache the result of RegisterName.
func Send[T any](id ID, sel SEL, args ...any) T {
var fn func(id ID, sel SEL, args ...any) T
var zero T
if runtime.GOARCH == "amd64" &&
reflect.ValueOf(zero).Kind() == reflect.Struct &&
reflect.ValueOf(zero).Type().Size() > maxRegAllocStructSize {
purego.RegisterFunc(&fn, objc_msgSend_stret_fn)
} else {
purego.RegisterFunc(&fn, objc_msgSend_fn)
}
return fn(id, sel, args...)
}
// objc_super data structure is generated by the Objective-C compiler when it encounters the super keyword
// as the receiver of a message. It specifies the class definition of the particular superclass that should
// be messaged.
type objc_super struct {
receiver ID
superClass Class
}
// SendSuper is a convenience method for sending message to object's super. This function takes a SEL
// instead of a string since RegisterName grabs the global Objective-C lock. It is best to cache the result
// of RegisterName.
func (id ID) SendSuper(sel SEL, args ...any) ID {
super := &objc_super{
receiver: id,
superClass: id.Class(),
}
return objc_msgSendSuper2(super, sel, args...)
}
// SendSuper is a convenience method for sending message to object's super that can return any type.
// This function takes a SEL instead of a string since RegisterName grabs the global Objective-C lock.
// It is best to cache the result of RegisterName.
func SendSuper[T any](id ID, sel SEL, args ...any) T {
super := &objc_super{
receiver: id,
superClass: id.Class(),
}
var fn func(objcSuper *objc_super, sel SEL, args ...any) T
var zero T
if runtime.GOARCH == "amd64" &&
reflect.ValueOf(zero).Kind() == reflect.Struct &&
reflect.ValueOf(zero).Type().Size() > maxRegAllocStructSize {
purego.RegisterFunc(&fn, objc_msgSendSuper2_stret_fn)
} else {
purego.RegisterFunc(&fn, objc_msgSendSuper2_fn)
}
return fn(super, sel, args...)
}
// SEL is an opaque type that represents a method selector
type SEL uintptr
// RegisterName registers a method with the Objective-C runtime system, maps the method name to a selector,
// and returns the selector value. This function grabs the global Objective-c lock. It is best to cache the
// result of this function.
func RegisterName(name string) SEL {
return sel_registerName(name)
}
// Class is an opaque type that represents an Objective-C class.
type Class uintptr
// GetClass returns the Class object for the named class, or nil if the class is not registered with the Objective-C runtime.
func GetClass(name string) Class {
return objc_getClass(name)
}
// MethodDef represents the Go function and the selector that ObjC uses to access that function.
type MethodDef struct {
Cmd SEL
Fn any
}
// IvarAttrib is the attribute that an ivar has. It affects if and which methods are automatically
// generated when creating a class with RegisterClass. See [Apple Docs] for an understanding of these attributes.
// The fields are still accessible using objc.GetIvar and objc.SetIvar regardless of the value of IvarAttrib.
//
// Take for example this Objective-C code:
//
// @property (readwrite) float value;
//
// In Go, the functions can be accessed as follows:
//
// var value = purego.Send[float32](id, purego.RegisterName("value"))
// id.Send(purego.RegisterName("setValue:"), 3.46)
//
// [Apple Docs]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjectiveC/Chapters/ocProperties.html
type IvarAttrib int
const (
ReadOnly IvarAttrib = 1 << iota
ReadWrite
)
// FieldDef is a definition of a field to add to an Objective-C class.
// The name of the field is what will be used to access it through the Ivar. If the type is bool
// the name cannot start with `is` since a getter will be generated with the name `isBoolName`.
// The name also cannot contain any spaces.
// The type is the Go equivalent type of the Ivar.
// Attribute determines if a getter and or setter method is generated for this field.
type FieldDef struct {
Name string
Type reflect.Type
Attribute IvarAttrib
}
// ivarRegex checks to make sure the Ivar is correctly formatted
var ivarRegex = regexp.MustCompile("[a-z_][a-zA-Z0-9_]*")
// RegisterClass takes the name of the class to create, the superclass, a list of protocols this class
// implements, a list of fields this class has and a list of methods. It returns the created class or an error
// describing what went wrong.
func RegisterClass(name string, superClass Class, protocols []*Protocol, ivars []FieldDef, methods []MethodDef) (Class, error) {
class := objc_allocateClassPair(superClass, name, 0)
if class == 0 {
return 0, fmt.Errorf("objc: failed to create class with name '%s'", name)
}
// Add Protocols
for _, p := range protocols {
if !class.AddProtocol(p) {
return 0, fmt.Errorf("objc: couldn't add Protocol %s", protocol_getName(p))
}
}
// Add exported methods based on the selectors returned from ClassDef(string) SEL
for idx, def := range methods {
imp, err := func() (imp IMP, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("objc: failed to create IMP: %s", r)
}
}()
return NewIMP(def.Fn), nil
}()
if err != nil {
return 0, fmt.Errorf("objc: couldn't add Method at index %d: %w", idx, err)
}
encoding, err := encodeFunc(def.Fn)
if err != nil {
return 0, fmt.Errorf("objc: couldn't add Method at index %d: %w", idx, err)
}
if !class.AddMethod(def.Cmd, imp, encoding) {
return 0, fmt.Errorf("objc: couldn't add Method at index %d", idx)
}
}
// Add Ivars
for _, instVar := range ivars {
ivar := instVar
if !ivarRegex.MatchString(ivar.Name) {
return 0, fmt.Errorf("objc: Ivar must start with a lowercase letter and only contain ASCII letters and numbers: '%s'", ivar.Name)
}
size := ivar.Type.Size()
alignment := uint8(math.Log2(float64(ivar.Type.Align())))
enc, err := encodeType(ivar.Type, false)
if err != nil {
return 0, fmt.Errorf("objc: couldn't add Ivar %s: %w", ivar.Name, err)
}
if !class_addIvar(class, ivar.Name, size, alignment, enc) {
return 0, fmt.Errorf("objc: couldn't add Ivar %s", ivar.Name)
}
offset := class.InstanceVariable(ivar.Name).Offset()
switch ivar.Attribute {
case ReadWrite:
ty := reflect.FuncOf(
[]reflect.Type{
reflect.TypeOf(ID(0)), reflect.TypeOf(SEL(0)), ivar.Type,
},
nil, false,
)
var encoding string
if encoding, err = encodeFunc(reflect.New(ty).Elem().Interface()); err != nil {
return 0, fmt.Errorf("objc: failed to create read method for '%s': %w", ivar.Name, err)
}
val := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) {
// on entry the first and second arguments are ID and SEL followed by the value
if len(args) != 3 {
panic(fmt.Sprintf("objc: incorrect number of args. expected 3 got %d", len(args)))
}
// The following reflect code does the equivalent of this:
//
// ((*struct {
// Padding [offset]byte
// Value int
// })(unsafe.Pointer(args[0].Interface().(ID)))).v = 123
//
// However, since the type of the variable is unknown reflection is used to actually assign the value
id, ok := xreflect.TypeAssert[ID](args[0])
if !ok {
panic(fmt.Sprintf("objc: id argument is not a ID but %s", args[0].Type().String()))
}
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&id)) // circumvent go vet
reflect.NewAt(ivar.Type, unsafe.Add(ptr, offset)).Elem().Set(args[2])
return nil
}).Interface()
// this code only works for ascii but that shouldn't be a problem
selector := "set" + string(unicode.ToUpper(rune(ivar.Name[0]))) + ivar.Name[1:] + ":\x00"
class.AddMethod(RegisterName(selector), NewIMP(val), encoding)
fallthrough // also implement the read method
case ReadOnly:
ty := reflect.FuncOf(
[]reflect.Type{
reflect.TypeOf(ID(0)), reflect.TypeOf(SEL(0)),
},
[]reflect.Type{ivar.Type}, false,
)
var encoding string
if encoding, err = encodeFunc(reflect.New(ty).Elem().Interface()); err != nil {
return 0, fmt.Errorf("objc: failed to create read method for '%s': %w", ivar.Name, err)
}
val := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) {
// on entry the first and second arguments are ID and SEL
if len(args) != 2 {
panic(fmt.Sprintf("objc: incorrect number of args. expected 2 got %d", len(args)))
}
id, ok := xreflect.TypeAssert[ID](args[0])
if !ok {
panic(fmt.Sprintf("objc: id argument is not a ID but %s", args[0].Type().String()))
}
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&id)) // circumvent go vet
// the variable is located at an offset from the id
return []reflect.Value{reflect.NewAt(ivar.Type, unsafe.Add(ptr, offset)).Elem()}
}).Interface()
if ivar.Type.Kind() == reflect.Bool {
// this code only works for ascii but that shouldn't be a problem
ivar.Name = "is" + string(unicode.ToUpper(rune(ivar.Name[0]))) + ivar.Name[1:]
}
class.AddMethod(RegisterName(ivar.Name), NewIMP(val), encoding)
default:
return 0, fmt.Errorf("objc: unknown Ivar Attribute (%d)", ivar.Attribute)
}
}
objc_registerClassPair(class)
return class, nil
}
const (
encId = "@"
encClass = "#"
encSelector = ":"
encChar = "c"
encUChar = "C"
encShort = "s"
encUShort = "S"
encInt = "i"
encUInt = "I"
encLong = "l"
encULong = "L"
encFloat = "f"
encDouble = "d"
encBool = "B"
encVoid = "v"
encPtr = "^"
encCharPtr = "*"
encStructBegin = "{"
encStructEnd = "}"
encUnsafePtr = "^v"
)
// encodeType returns a string representing a type as if it was given to @encode(typ)
// Source: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html#//apple_ref/doc/uid/TP40008048-CH100
func encodeType(typ reflect.Type, insidePtr bool) (string, error) {
switch typ {
case reflect.TypeOf(Class(0)):
return encClass, nil
case reflect.TypeOf(ID(0)), reflect.TypeOf(Block(0)):
return encId, nil
case reflect.TypeOf(SEL(0)):
return encSelector, nil
}
kind := typ.Kind()
switch kind {
case reflect.Bool:
return encBool, nil
case reflect.Int:
return encLong, nil
case reflect.Int8:
return encChar, nil
case reflect.Int16:
return encShort, nil
case reflect.Int32:
return encInt, nil
case reflect.Int64:
return encULong, nil
case reflect.Uint:
return encULong, nil
case reflect.Uint8:
return encUChar, nil
case reflect.Uint16:
return encUShort, nil
case reflect.Uint32:
return encUInt, nil
case reflect.Uint64:
return encULong, nil
case reflect.Uintptr:
return encPtr, nil
case reflect.Float32:
return encFloat, nil
case reflect.Float64:
return encDouble, nil
case reflect.Ptr:
enc, err := encodeType(typ.Elem(), true)
return encPtr + enc, err
case reflect.Struct:
if insidePtr {
return encStructBegin + typ.Name() + encStructEnd, nil
}
encoding := encStructBegin
encoding += typ.Name()
encoding += "="
for i := 0; i < typ.NumField(); i++ {
f := typ.Field(i)
tmp, err := encodeType(f.Type, false)
if err != nil {
return "", err
}
encoding += tmp
}
encoding += encStructEnd
return encoding, nil
case reflect.UnsafePointer:
return encUnsafePtr, nil
case reflect.String:
return encCharPtr, nil
}
return "", errors.New(fmt.Sprintf("unhandled/invalid kind %v typed %v", kind, typ))
}
// encodeFunc returns a functions type as if it was given to @encode(fn)
func encodeFunc(fn any) (string, error) {
typ := reflect.TypeOf(fn)
if typ.Kind() != reflect.Func {
return "", errors.New("not a func")
}
encoding := ""
switch typ.NumOut() {
case 0:
encoding += encVoid
case 1:
tmp, err := encodeType(typ.Out(0), false)
if err != nil {
return "", err
}
encoding += tmp
default:
return "", errors.New("too many output parameters")
}
if typ.NumIn() < 2 {
return "", errors.New("func doesn't take ID and SEL as its first two parameters")
}
encoding += encId
for i := 1; i < typ.NumIn(); i++ {
tmp, err := encodeType(typ.In(i), false)
if err != nil {
return "", err
}
encoding += tmp
}
return encoding, nil
}
// SuperClass returns the superclass of a class.
// You should usually use NSObject‘s superclass method instead of this function.
func (c Class) SuperClass() Class {
return class_getSuperclass(c)
}
// AddMethod adds a new method to a class with a given name and implementation.
// The types argument is a string containing the mapping of parameters and return type.
// Since the function must take at least two arguments—self and _cmd, the second and third
// characters must be “@:” (the first character is the return type).
func (c Class) AddMethod(name SEL, imp IMP, types string) bool {
return class_addMethod(c, name, imp, types)
}
// AddProtocol adds a protocol to a class.
// Returns true if the protocol was added successfully, otherwise false (for example,
// the class already conforms to that protocol).
func (c Class) AddProtocol(protocol *Protocol) bool {
return class_addProtocol(c, protocol)
}
// InstanceSize returns the size in bytes of instances of the class or 0 if cls is nil
func (c Class) InstanceSize() uintptr {
return class_getInstanceSize(c)
}
// InstanceVariable returns an Ivar data structure containing information about the instance variable specified by name.
func (c Class) InstanceVariable(name string) Ivar {
return class_getInstanceVariable(c, name)
}
// Ivar an opaque type that represents an instance variable.
type Ivar uintptr
// Offset returns the offset of an instance variable that can be used to assign and read the Ivar's value.
//
// For instance variables of type ID or other object types, call Ivar and SetIvar instead
// of using this offset to access the instance variable data directly.
func (i Ivar) Offset() uintptr {
return ivar_getOffset(i)
}
func (i Ivar) Name() string {
return ivar_getName(i)
}
// MethodDescription holds the name and type definition of a method.
type MethodDescription struct {
name, types uintptr
}
// Name returns the name of this method.
func (m MethodDescription) Name() string {
return strings.GoString(m.name)
}
// Types returns the OBJC runtime encoded type description.
func (m MethodDescription) Types() string {
return strings.GoString(m.types)
}
// PropertyAttribute contains the null-terminated Name and Value pair of a Properties internal description.
type PropertyAttribute struct {
Name, Value *byte
}
// Property is an opaque type for Objective-C property metadata.
type Property uintptr
// Name returns the name of this property.
func (p Property) Name() string {
return property_getName(p)
}
// Attributes returns a comma separated list of PropertyAttribute
func (p Property) Attributes() string {
return property_getAttributes(p)
}
// Protocol is a type that declares methods that can be implemented by any class.
type Protocol [0]func()
// GetProtocol returns the protocol for the given name or nil if there is no protocol by that name.
func GetProtocol(name string) *Protocol {
return objc_getProtocol(name)
}
// AllocateProtocol creates a new protocol in the OBJC runtime or nil if the protocol already exists.
func AllocateProtocol(name string) *Protocol {
return objc_allocateProtocol(name)
}
// Register registers the protocol created using AllocateProtocol with the runtime. This must be done
// before it is used anywhere and can only be called once.
func (p *Protocol) Register() {
objc_registerProtocol(p)
}
// CopyMethodDescriptionList returns a list of methods that this protocol has given it isRequiredMethod and isInstanceMethod.
func (p *Protocol) CopyMethodDescriptionList(isRequiredMethod, isInstanceMethod bool) []MethodDescription {
count := uint32(0)
desc := protocol_copyMethodDescriptionList(p, isRequiredMethod, isInstanceMethod, &count)
methods := clone(unsafe.Slice(desc, count))
free(unsafe.Pointer(desc))
return methods
}
// CopyProtocolList returns a list of the protocols that this protocol inherits from.
func (p *Protocol) CopyProtocolList() []*Protocol {
count := uint32(0)
desc := protocol_copyProtocolList(p, &count)
protocols := clone(unsafe.Slice(desc, count))
free(unsafe.Pointer(desc))
return protocols
}
// CopyPropertyList returns a list of properties that this protocol has given it isRequiredProperty and isInstanceProperty.
func (p *Protocol) CopyPropertyList(isRequiredProperty, isInstanceProperty bool) []Property {
count := uint32(0)
desc := protocol_copyPropertyList2(p, &count, isRequiredProperty, isInstanceProperty)
protocols := clone(unsafe.Slice(desc, count))
free(unsafe.Pointer(desc))
return protocols
}
// Name returns the name of this protocol.
func (p *Protocol) Name() string {
return protocol_getName(p)
}
// Equals return true if the two protocols are the same.
func (p *Protocol) Equals(p2 *Protocol) bool {
return protocol_isEqual(p, p2)
}
// AddMethodDescription adds a method to a protocol. This can only be called between AllocateProtocol and Protocol.Register.
func (p *Protocol) AddMethodDescription(name SEL, types string, isRequiredMethod, isInstanceMethod bool) {
protocol_addMethodDescription(p, name, types, isRequiredMethod, isInstanceMethod)
}
// AddProtocol marks the protocol as inheriting from another. This can only be called between AllocateProtocol and Protocol.Register.
func (p *Protocol) AddProtocol(protocol *Protocol) {
protocol_addProtocol(p, protocol)
}
// AddProperty adds a property to the protocol. This can only be called between AllocateProtocol and Protocol.Register.
func (p *Protocol) AddProperty(name string, attributes []PropertyAttribute, isRequiredProperty, isInstanceProperty bool) {
protocol_addProperty(p, name, attributes, uint32(len(attributes)), isRequiredProperty, isInstanceProperty)
}
// IMP is a function pointer that can be called by Objective-C code.
type IMP uintptr
// NewIMP takes a Go function that takes (ID, SEL) as its first two arguments.
// It returns an IMP function pointer that can be called by Objective-C code.
// The function panics if an error occurs.
// The function pointer is never deallocated.
func NewIMP(fn any) IMP {
ty := reflect.TypeOf(fn)
if ty.Kind() != reflect.Func {
panic("objc: not a function")
}
// IMP is stricter than a normal callback
// id (*IMP)(id, SEL, ...)
switch {
case ty.NumIn() < 2:
fallthrough
case ty.In(0) != reflect.TypeOf(ID(0)):
fallthrough
case ty.In(1) != reflect.TypeOf(SEL(0)):
panic("objc: NewIMP must take a (id, SEL) as its first two arguments; got " + ty.String())
}
return IMP(purego.NewCallback(fn))
}
// TODO: remove and use slices.Clone when minimum version for purego is 1.21
func clone[S ~[]E, E any](s S) S {
// Preserve nilness in case it matters.
if s == nil {
return nil
}
// Avoid s[:0:0] as it leads to unwanted liveness when cloning a
// zero-length slice of a large array; see https://go.dev/issue/68488.
return append(S{}, s...)
}
golang-github-ebitengine-purego-0.10.1/objc/objc_runtime_darwin_test.go 0000664 0000000 0000000 00000012574 15207302613 0026265 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
package objc_test
import (
"fmt"
"log"
"reflect"
"testing"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/objc"
)
func ExampleRegisterClass_helloworld() {
class, err := objc.RegisterClass(
"FooObject",
objc.GetClass("NSObject"),
nil,
nil,
[]objc.MethodDef{
{
Cmd: objc.RegisterName("run"),
Fn: func(self objc.ID, _cmd objc.SEL) {
fmt.Println("Hello World!")
},
},
},
)
if err != nil {
panic(err)
}
object := objc.ID(class).Send(objc.RegisterName("new"))
object.Send(objc.RegisterName("run"))
// Output: Hello World!
}
func ExampleRegisterClass() {
var (
sel_new = objc.RegisterName("new")
sel_init = objc.RegisterName("init")
sel_setBar = objc.RegisterName("setBar:")
sel_bar = objc.RegisterName("bar")
BarInit = func(id objc.ID, cmd objc.SEL) objc.ID {
return id.SendSuper(cmd)
}
)
class, err := objc.RegisterClass(
"BarObject",
objc.GetClass("NSObject"),
[]*objc.Protocol{
objc.GetProtocol("NSDelegateWindow"),
},
[]objc.FieldDef{
{
Name: "bar",
Type: reflect.TypeOf(int(0)),
Attribute: objc.ReadWrite,
},
{
Name: "foo",
Type: reflect.TypeOf(false),
Attribute: objc.ReadWrite,
},
},
[]objc.MethodDef{
{
Cmd: sel_init,
Fn: BarInit,
},
},
)
if err != nil {
panic(err)
}
object := objc.ID(class).Send(sel_new)
object.Send(sel_setBar, 123)
bar := int(object.Send(sel_bar))
fmt.Println(bar)
// Output: 123
}
func ExampleIMP() {
imp := objc.NewIMP(func(self objc.ID, _cmd objc.SEL, a3, a4, a5, a6, a7, a8, a9 int) {
fmt.Println("IMP:", self, _cmd, a3, a4, a5, a6, a7, a8, a9)
})
purego.SyscallN(uintptr(imp), 105, 567, 9, 2, 3, ^uintptr(4), 4, 8, 9)
// Output: IMP: 105 567 9 2 3 -5 4 8 9
}
func ExampleID_SendSuper() {
super, err := objc.RegisterClass(
"SuperObject",
objc.GetClass("NSObject"),
nil,
nil,
[]objc.MethodDef{
{
Cmd: objc.RegisterName("doSomething"),
Fn: func(self objc.ID, _cmd objc.SEL) {
fmt.Println("In Super!")
},
},
},
)
if err != nil {
panic(err)
}
child, err := objc.RegisterClass(
"ChildObject",
super,
nil,
nil,
[]objc.MethodDef{
{
Cmd: objc.RegisterName("doSomething"),
Fn: func(self objc.ID, _cmd objc.SEL) {
fmt.Println("In Child")
self.SendSuper(_cmd)
},
},
},
)
if err != nil {
panic(err)
}
objc.ID(child).Send(objc.RegisterName("new")).Send(objc.RegisterName("doSomething"))
// Output: In Child
// In Super!
}
func TestSend(t *testing.T) {
// NSNumber comes from Foundation so make sure we have linked to that framework.
_, err := purego.Dlopen("/System/Library/Frameworks/Foundation.framework/Foundation", purego.RTLD_GLOBAL|purego.RTLD_NOW)
if err != nil {
t.Fatal(err)
}
const double = float64(2.34)
// Initialize a NSNumber
NSNumber := objc.ID(objc.GetClass("NSNumber")).Send(objc.RegisterName("numberWithDouble:"), double)
// Then get that number back using the generic Send function.
number := objc.Send[float64](NSNumber, objc.RegisterName("doubleValue"))
if double != number {
t.Failed()
}
}
func ExampleSend() {
type NSRange struct {
Location, Range uint
}
class_NSString := objc.GetClass("NSString")
sel_stringWithUTF8String := objc.RegisterName("stringWithUTF8String:")
fullString := objc.ID(class_NSString).Send(sel_stringWithUTF8String, "Hello, World!\x00")
subString := objc.ID(class_NSString).Send(sel_stringWithUTF8String, "lo, Wor\x00")
r := objc.Send[NSRange](fullString, objc.RegisterName("rangeOfString:"), subString)
fmt.Println(r)
// Output: {3 7}
}
func ExampleSendSuper() {
super, err := objc.RegisterClass(
"SuperObject2",
objc.GetClass("NSObject"),
nil,
nil,
[]objc.MethodDef{
{
Cmd: objc.RegisterName("doSomething"),
Fn: func(self objc.ID, _cmd objc.SEL) int {
return 16
},
},
},
)
if err != nil {
panic(err)
}
child, err := objc.RegisterClass(
"ChildObject2",
super,
nil,
nil,
[]objc.MethodDef{
{
Cmd: objc.RegisterName("doSomething"),
Fn: func(self objc.ID, _cmd objc.SEL) int {
return 24
},
},
},
)
if err != nil {
panic(err)
}
res := objc.SendSuper[int](objc.ID(child).Send(objc.RegisterName("new")), objc.RegisterName("doSomething"))
fmt.Println(res)
// Output: 16
}
func ExampleAllocateProtocol() {
var p *objc.Protocol
if p = objc.AllocateProtocol("MyCustomProtocol"); p != nil {
p.AddMethodDescription(objc.RegisterName("isFoo"), "B16@0:8", true, true)
var adoptedProtocol *objc.Protocol
adoptedProtocol = objc.GetProtocol("NSObject")
if adoptedProtocol == nil {
log.Fatalln("protocol 'NSObject' does not exist")
}
p.AddProtocol(adoptedProtocol)
p.AddProperty("accessibilityElement", []objc.PropertyAttribute{
{Name: &[]byte("T\x00")[0], Value: &[]byte("B\x00")[0]},
{Name: &[]byte("G\x00")[0], Value: &[]byte("isBar\x00")[0]},
}, true, true)
p.Register()
}
p = objc.GetProtocol("MyCustomProtocol")
for _, protocol := range p.CopyProtocolList() {
fmt.Println(protocol.Name())
}
for _, property := range p.CopyPropertyList(true, true) {
fmt.Println(property.Name(), property.Attributes())
}
for _, method := range p.CopyMethodDescriptionList(true, true) {
fmt.Println(method.Name(), method.Types())
}
// Output:
// NSObject
// accessibilityElement TB,GisBar
// isFoo B16@0:8
}
golang-github-ebitengine-purego-0.10.1/struct_386.go 0000664 0000000 0000000 00000002757 15207302613 0022213 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package purego
import "reflect"
func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
panic("purego: struct arguments are not supported")
}
func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
panic("purego: struct returns are not supported")
}
func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
panic("purego: placeRegisters not implemented on 386")
}
// shouldBundleStackArgs always returns false on 386
// since C-style stack argument bundling is only needed on Darwin ARM64.
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
return false
}
// structFitsInRegisters is not used on 386.
func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
panic("purego: structFitsInRegisters should not be called on 386")
}
// collectStackArgs is not used on 386.
func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
keepAlive []any, addInt, addFloat, addStack func(uintptr),
pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
panic("purego: collectStackArgs should not be called on 386")
}
// bundleStackArgs is not used on 386.
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("purego: bundleStackArgs should not be called on 386")
}
golang-github-ebitengine-purego-0.10.1/struct_amd64.go 0000664 0000000 0000000 00000017404 15207302613 0022601 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package purego
import (
"math"
"reflect"
"unsafe"
)
func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 8:
if isAllFloats(outType) {
// 2 float32s or 1 float64s are return in the float register
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.f1})).Elem()
}
// up to 8 bytes is returned in RAX
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.a1})).Elem()
case outSize <= 16:
r1, r2 := syscall.a1, syscall.a2
if isAllFloats(outType) {
r1 = syscall.f1
r2 = syscall.f2
} else {
// check first 8 bytes if it's floats
hasFirstFloat := false
f1 := outType.Field(0).Type
if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && outType.Field(1).Type.Kind() == reflect.Float32 {
r1 = syscall.f1
hasFirstFloat = true
}
// find index of the field that starts the second 8 bytes
var i int
for i = 0; i < outType.NumField(); i++ {
if outType.Field(i).Offset == 8 {
break
}
}
// check last 8 bytes if they are floats
f1 = outType.Field(i).Type
if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && i+1 == outType.NumField() {
r2 = syscall.f1
} else if hasFirstFloat {
// if the first field was a float then that means the second integer field
// comes from the first integer register
r2 = syscall.a1
}
}
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem()
default:
// create struct from the Go pointer created above
// weird pointer dereference to circumvent go vet
return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem()
}
}
func isAllFloats(ty reflect.Type) bool {
for i := 0; i < ty.NumField(); i++ {
f := ty.Field(i)
switch f.Type.Kind() {
case reflect.Float64, reflect.Float32:
default:
return false
}
}
return true
}
// https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf
// https://gitlab.com/x86-psABIs/x86-64-ABI
// Class determines where the 8 byte value goes.
// Higher value classes win over lower value classes
const (
_NO_CLASS = 0b0000
_SSE = 0b0001
_X87 = 0b0011 // long double not used in Go
_INTEGER = 0b0111
_MEMORY = 0b1111
)
func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
if v.Type().Size() == 0 {
return keepAlive
}
// if greater than 64 bytes place on stack
if v.Type().Size() > 8*8 {
placeStack(v, addStack)
return keepAlive
}
var (
savedNumFloats = *numFloats
savedNumInts = *numInts
savedNumStack = *numStack
)
placeOnStack := postMerger(v.Type()) || !tryPlaceRegister(v, addFloat, addInt)
if placeOnStack {
// reset any values placed in registers
*numFloats = savedNumFloats
*numInts = savedNumInts
*numStack = savedNumStack
placeStack(v, addStack)
}
return keepAlive
}
func postMerger(t reflect.Type) (passInMemory bool) {
// (c) If the size of the aggregate exceeds two eightbytes and the first eight- byte isn’t SSE or any other
// eightbyte isn’t SSEUP, the whole argument is passed in memory.
if t.Kind() != reflect.Struct {
return false
}
if t.Size() <= 2*8 {
return false
}
return true // Go does not have an SSE/SSEUP type so this is always true
}
func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) (ok bool) {
ok = true
var val uint64
var shift byte // # of bits to shift
var flushed bool
class := _NO_CLASS
flushIfNeeded := func() {
if flushed {
return
}
flushed = true
if class == _SSE {
addFloat(uintptr(val))
} else {
addInt(uintptr(val))
}
val = 0
shift = 0
class = _NO_CLASS
}
var place func(v reflect.Value)
place = func(v reflect.Value) {
var numFields int
if v.Kind() == reflect.Struct {
numFields = v.Type().NumField()
} else {
numFields = v.Type().Len()
}
for i := 0; i < numFields; i++ {
flushed = false
var f reflect.Value
if v.Kind() == reflect.Struct {
f = v.Field(i)
} else {
f = v.Index(i)
}
switch f.Kind() {
case reflect.Struct:
place(f)
case reflect.Bool:
if f.Bool() {
val |= 1 << shift
}
shift += 8
class |= _INTEGER
case reflect.Pointer, reflect.UnsafePointer:
val = uint64(f.Pointer())
shift = 64
class = _INTEGER
case reflect.Int8:
val |= uint64(f.Int()&0xFF) << shift
shift += 8
class |= _INTEGER
case reflect.Int16:
val |= uint64(f.Int()&0xFFFF) << shift
shift += 16
class |= _INTEGER
case reflect.Int32:
val |= uint64(f.Int()&0xFFFF_FFFF) << shift
shift += 32
class |= _INTEGER
case reflect.Int64, reflect.Int:
val = uint64(f.Int())
shift = 64
class = _INTEGER
case reflect.Uint8:
val |= f.Uint() << shift
shift += 8
class |= _INTEGER
case reflect.Uint16:
val |= f.Uint() << shift
shift += 16
class |= _INTEGER
case reflect.Uint32:
val |= f.Uint() << shift
shift += 32
class |= _INTEGER
case reflect.Uint64, reflect.Uint, reflect.Uintptr:
val = f.Uint()
shift = 64
class = _INTEGER
case reflect.Float32:
val |= uint64(math.Float32bits(float32(f.Float()))) << shift
shift += 32
class |= _SSE
case reflect.Float64:
if v.Type().Size() > 16 {
ok = false
return
}
val = uint64(math.Float64bits(f.Float()))
shift = 64
class = _SSE
case reflect.Array:
place(f)
default:
panic("purego: unsupported kind " + f.Kind().String())
}
if shift == 64 {
flushIfNeeded()
} else if shift > 64 {
// Should never happen, but may if we forget to reset shift after flush (or forget to flush),
// better fall apart here, than corrupt arguments.
panic("purego: tryPlaceRegisters shift > 64")
}
}
}
place(v)
flushIfNeeded()
return ok
}
func placeStack(v reflect.Value, addStack func(uintptr)) {
// Copy the struct as a contiguous block of memory in eightbyte (8-byte)
// chunks. The x86-64 ABI requires structs passed on the stack to be
// laid out exactly as in memory, including padding and field packing
// within eightbytes. Decomposing field-by-field would place each field
// as a separate stack slot, breaking structs with mixed-type fields
// that share an eightbyte (e.g. int32 + float32).
if !v.CanAddr() {
tmp := reflect.New(v.Type()).Elem()
tmp.Set(v)
v = tmp
}
ptr := v.Addr().UnsafePointer()
size := v.Type().Size()
for off := uintptr(0); off < size; off += 8 {
chunk := *(*uintptr)(unsafe.Add(ptr, off))
addStack(chunk)
}
}
func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
panic("purego: placeRegisters not implemented on amd64")
}
// shouldBundleStackArgs always returns false on non-Darwin platforms
// since C-style stack argument bundling is only needed on Darwin ARM64.
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
return false
}
// structFitsInRegisters is not used on amd64.
func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
panic("purego: structFitsInRegisters should not be called on amd64")
}
// collectStackArgs is not used on amd64.
func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
keepAlive []any, addInt, addFloat, addStack func(uintptr),
pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
panic("purego: collectStackArgs should not be called on amd64")
}
// bundleStackArgs is not used on amd64.
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("purego: bundleStackArgs should not be called on amd64")
}
golang-github-ebitengine-purego-0.10.1/struct_arm.go 0000664 0000000 0000000 00000005025 15207302613 0022441 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package purego
import (
"reflect"
"unsafe"
)
func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
size := v.Type().Size()
if size == 0 {
return keepAlive
}
// TODO: ARM EABI: small structs are passed in registers or on stack
// For simplicity, pass by pointer for now
ptr := v.Addr().UnsafePointer()
keepAlive = append(keepAlive, ptr)
if *numInts < 4 {
addInt(uintptr(ptr))
*numInts++
} else {
addStack(uintptr(ptr))
*numStack++
}
return keepAlive
}
func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
outSize := outType.Size()
if outSize == 0 {
return reflect.New(outType).Elem()
}
if outSize <= 4 {
// Fits in one register
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.a1})).Elem()
}
if outSize <= 8 {
// Fits in two registers
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{syscall.a1, syscall.a2})).Elem()
}
// Larger structs returned via pointer in a1
return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem()
}
func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
// TODO: For ARM32, just pass the struct data directly
// This is a simplified implementation
size := v.Type().Size()
if size == 0 {
return
}
ptr := unsafe.Pointer(v.UnsafeAddr())
if size <= 4 {
addInt(*(*uintptr)(ptr))
} else if size <= 8 {
addInt(*(*uintptr)(ptr))
addInt(*(*uintptr)(unsafe.Add(ptr, 4)))
}
}
// shouldBundleStackArgs always returns false on arm
// since C-style stack argument bundling is only needed on Darwin ARM64.
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
return false
}
// structFitsInRegisters is not used on arm.
func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
panic("purego: structFitsInRegisters should not be called on arm")
}
// collectStackArgs is not used on arm.
func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
keepAlive []any, addInt, addFloat, addStack func(uintptr),
pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
panic("purego: collectStackArgs should not be called on arm")
}
// bundleStackArgs is not used on arm.
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("purego: bundleStackArgs should not be called on arm")
}
golang-github-ebitengine-purego-0.10.1/struct_arm64.go 0000664 0000000 0000000 00000037632 15207302613 0022624 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
package purego
import (
"math"
"reflect"
"runtime"
"strconv"
stdstrings "strings"
"unsafe"
"github.com/ebitengine/purego/internal/strings"
)
func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 8:
r1 := syscall.a1
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
r1 = syscall.f1
if numFields == 2 {
r1 = syscall.f2<<32 | syscall.f1
}
}
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem()
case outSize <= 16:
r1, r2 := syscall.a1, syscall.a2
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
switch numFields {
case 4:
r1 = syscall.f2<<32 | syscall.f1
r2 = syscall.f4<<32 | syscall.f3
case 3:
r1 = syscall.f2<<32 | syscall.f1
r2 = syscall.f3
case 2:
r1 = syscall.f1
r2 = syscall.f2
default:
panic("unreachable")
}
}
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem()
default:
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats && numFields <= 4 {
switch numFields {
case 4:
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c, d uintptr }{syscall.f1, syscall.f2, syscall.f3, syscall.f4})).Elem()
case 3:
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c uintptr }{syscall.f1, syscall.f2, syscall.f3})).Elem()
default:
panic("unreachable")
}
}
// create struct from the Go pointer created in arm64_r8
// weird pointer dereference to circumvent go vet
return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.arm64_r8))).Elem()
}
}
// https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst
const (
_NO_CLASS = 0b00
_FLOAT = 0b01
_INT = 0b11
)
func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
if v.Type().Size() == 0 {
return keepAlive
}
if hva, hfa, size := isHVA(v.Type()), isHFA(v.Type()), v.Type().Size(); hva || hfa || size <= 16 {
// if this doesn't fit entirely in registers then
// each element goes onto the stack
if hfa && *numFloats+v.NumField() > numOfFloatRegisters() {
*numFloats = numOfFloatRegisters()
} else if hva && *numInts+v.NumField() > numOfIntegerRegisters() {
*numInts = numOfIntegerRegisters()
}
placeRegisters(v, addFloat, addInt)
} else {
keepAlive = placeStack(v, keepAlive, addInt)
}
return keepAlive // the struct was allocated so don't panic
}
func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
if runtime.GOOS == "darwin" {
placeRegistersDarwin(v, addFloat, addInt)
return
}
placeRegistersArm64(v, addFloat, addInt)
}
func placeRegistersArm64(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
var val uint64
var shift byte
var flushed bool
class := _NO_CLASS
var place func(v reflect.Value)
place = func(v reflect.Value) {
var numFields int
if v.Kind() == reflect.Struct {
numFields = v.Type().NumField()
} else {
numFields = v.Type().Len()
}
for k := 0; k < numFields; k++ {
flushed = false
var f reflect.Value
if v.Kind() == reflect.Struct {
f = v.Field(k)
} else {
f = v.Index(k)
}
align := byte(f.Type().Align()*8 - 1)
shift = (shift + align) &^ align
if shift >= 64 {
shift = 0
flushed = true
if class == _FLOAT {
addFloat(uintptr(val))
} else {
addInt(uintptr(val))
}
val = 0
class = _NO_CLASS
}
switch f.Type().Kind() {
case reflect.Struct:
place(f)
case reflect.Bool:
if f.Bool() {
val |= 1 << shift
}
shift += 8
class |= _INT
case reflect.Uint8:
val |= f.Uint() << shift
shift += 8
class |= _INT
case reflect.Uint16:
val |= f.Uint() << shift
shift += 16
class |= _INT
case reflect.Uint32:
val |= f.Uint() << shift
shift += 32
class |= _INT
case reflect.Uint64, reflect.Uint, reflect.Uintptr:
addInt(uintptr(f.Uint()))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Int8:
val |= uint64(f.Int()&0xFF) << shift
shift += 8
class |= _INT
case reflect.Int16:
val |= uint64(f.Int()&0xFFFF) << shift
shift += 16
class |= _INT
case reflect.Int32:
val |= uint64(f.Int()&0xFFFF_FFFF) << shift
shift += 32
class |= _INT
case reflect.Int64, reflect.Int:
addInt(uintptr(f.Int()))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Float32:
if class == _FLOAT {
addFloat(uintptr(val))
val = 0
shift = 0
}
val |= uint64(math.Float32bits(float32(f.Float()))) << shift
shift += 32
class |= _FLOAT
case reflect.Float64:
addFloat(uintptr(math.Float64bits(float64(f.Float()))))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Ptr, reflect.UnsafePointer:
addInt(f.Pointer())
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Array:
place(f)
default:
panic("purego: unsupported kind " + f.Kind().String())
}
}
}
place(v)
if !flushed {
if class == _FLOAT {
addFloat(uintptr(val))
} else {
addInt(uintptr(val))
}
}
}
func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
// Struct is too big to be placed in registers.
// Copy to heap and place the pointer in register
ptrStruct := reflect.New(v.Type())
ptrStruct.Elem().Set(v)
ptr := ptrStruct.Elem().Addr().UnsafePointer()
keepAlive = append(keepAlive, ptr)
addInt(uintptr(ptr))
return keepAlive
}
// isHFA reports a Homogeneous Floating-point Aggregate (HFA) which is a Fundamental Data Type that is a
// Floating-Point type and at most four uniquely addressable members (5.9.5.1 in [Arm64 Calling Convention]).
// This type of struct will be placed more compactly than the individual fields.
//
// [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst
func isHFA(t reflect.Type) bool {
// round up struct size to nearest 8 see section B.4
structSize := roundUpTo8(t.Size())
if structSize == 0 || t.NumField() > 4 {
return false
}
first := t.Field(0)
switch first.Type.Kind() {
case reflect.Float32, reflect.Float64:
firstKind := first.Type.Kind()
for i := 0; i < t.NumField(); i++ {
if t.Field(i).Type.Kind() != firstKind {
return false
}
}
return true
case reflect.Array:
switch first.Type.Elem().Kind() {
case reflect.Float32, reflect.Float64:
return true
default:
return false
}
case reflect.Struct:
for i := 0; i < first.Type.NumField(); i++ {
if !isHFA(first.Type) {
return false
}
}
return true
default:
return false
}
}
// isHVA reports a Homogeneous Aggregate with a Fundamental Data Type that is a Short-Vector type
// and at most four uniquely addressable members (5.9.5.2 in [Arm64 Calling Convention]).
// A short vector is a machine type that is composed of repeated instances of one fundamental integral or
// floating-point type. It may be 8 or 16 bytes in total size (5.4 in [Arm64 Calling Convention]).
// This type of struct will be placed more compactly than the individual fields.
//
// [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst
func isHVA(t reflect.Type) bool {
// round up struct size to nearest 8 see section B.4
structSize := roundUpTo8(t.Size())
if structSize == 0 || (structSize != 8 && structSize != 16) {
return false
}
first := t.Field(0)
switch first.Type.Kind() {
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32:
firstKind := first.Type.Kind()
for i := 0; i < t.NumField(); i++ {
if t.Field(i).Type.Kind() != firstKind {
return false
}
}
return true
case reflect.Array:
switch first.Type.Elem().Kind() {
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32:
return true
default:
return false
}
default:
return false
}
}
// copyStruct8ByteChunks copies struct memory in 8-byte chunks to the provided callback.
// This is used for Darwin ARM64's byte-level packing of non-HFA/HVA structs.
func copyStruct8ByteChunks(ptr unsafe.Pointer, size uintptr, addChunk func(uintptr)) {
if runtime.GOOS != "darwin" {
panic("purego: should only be called on darwin")
}
for offset := uintptr(0); offset < size; offset += 8 {
var chunk uintptr
remaining := size - offset
if remaining >= 8 {
chunk = *(*uintptr)(unsafe.Add(ptr, offset))
} else {
// Read byte-by-byte to avoid reading beyond allocation
for i := uintptr(0); i < remaining; i++ {
b := *(*byte)(unsafe.Add(ptr, offset+i))
chunk |= uintptr(b) << (i * 8)
}
}
addChunk(chunk)
}
}
// placeRegisters implements Darwin ARM64 calling convention for struct arguments.
//
// For HFA/HVA structs, each element must go in a separate register (or stack slot for elements
// that don't fit in registers). We use placeRegistersArm64 for this.
//
// For non-HFA/HVA structs, Darwin uses byte-level packing. We copy the struct memory in
// 8-byte chunks, which works correctly for both register and stack placement.
func placeRegistersDarwin(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
if runtime.GOOS != "darwin" {
panic("purego: placeRegistersDarwin should only be called on darwin")
}
// Check if this is an HFA/HVA
hfa := isHFA(v.Type())
hva := isHVA(v.Type())
// For HFA/HVA structs, use the standard ARM64 logic which places each element separately
if hfa || hva {
placeRegistersArm64(v, addFloat, addInt)
return
}
// For non-HFA/HVA structs, use byte-level copying
// If the value is not addressable, create an addressable copy
if !v.CanAddr() {
addressable := reflect.New(v.Type()).Elem()
addressable.Set(v)
v = addressable
}
ptr := unsafe.Pointer(v.Addr().Pointer())
size := v.Type().Size()
copyStruct8ByteChunks(ptr, size, addInt)
}
// shouldBundleStackArgs determines if we need to start C-style packing for
// Darwin ARM64 stack arguments. This happens when registers are exhausted.
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
if runtime.GOOS != "darwin" {
return false
}
kind := v.Kind()
isFloat := kind == reflect.Float32 || kind == reflect.Float64
isInt := !isFloat && kind != reflect.Struct
primitiveOnStack :=
(isInt && numInts >= numOfIntegerRegisters()) ||
(isFloat && numFloats >= numOfFloatRegisters())
if primitiveOnStack {
return true
}
if kind != reflect.Struct {
return false
}
hfa := isHFA(v.Type())
hva := isHVA(v.Type())
size := v.Type().Size()
eligible := hfa || hva || size <= 16
if !eligible {
return false
}
if hfa {
need := v.NumField()
return numFloats+need > numOfFloatRegisters()
}
if hva {
need := v.NumField()
return numInts+need > numOfIntegerRegisters()
}
slotsNeeded := int((size + align8ByteMask) / align8ByteSize)
return numInts+slotsNeeded > numOfIntegerRegisters()
}
// structFitsInRegisters determines if a struct can still fit in remaining
// registers, used during stack argument bundling to decide if a struct
// should go through normal register allocation or be bundled with stack args.
func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
if runtime.GOOS != "darwin" {
panic("purego: structFitsInRegisters should only be called on darwin")
}
hfa := isHFA(val.Type())
hva := isHVA(val.Type())
size := val.Type().Size()
if hfa {
// HFA: check if elements fit in float registers
if tempNumFloats+val.NumField() <= numOfFloatRegisters() {
return true, tempNumInts, tempNumFloats + val.NumField()
}
} else if hva {
// HVA: check if elements fit in int registers
if tempNumInts+val.NumField() <= numOfIntegerRegisters() {
return true, tempNumInts + val.NumField(), tempNumFloats
}
} else if size <= 16 {
// Non-HFA/HVA small structs use int registers for byte-packing
slotsNeeded := int((size + align8ByteMask) / align8ByteSize)
if tempNumInts+slotsNeeded <= numOfIntegerRegisters() {
return true, tempNumInts + slotsNeeded, tempNumFloats
}
}
return false, tempNumInts, tempNumFloats
}
// collectStackArgs separates remaining arguments into those that fit in registers vs those that go on stack.
// It returns the stack arguments and processes register arguments through addValue.
func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
keepAlive []any, addInt, addFloat, addStack func(uintptr),
pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
if runtime.GOOS != "darwin" {
panic("purego: collectStackArgs should only be called on darwin")
}
var stackArgs []reflect.Value
tempNumInts := numInts
tempNumFloats := numFloats
for j, val := range args[startIdx:] {
// Determine if this argument goes to register or stack
var fitsInRegister bool
var newNumInts, newNumFloats int
if val.Kind() == reflect.Struct {
// Check if struct still fits in remaining registers
fitsInRegister, newNumInts, newNumFloats = structFitsInRegisters(val, tempNumInts, tempNumFloats)
} else {
// Primitive argument
isFloat := val.Kind() == reflect.Float32 || val.Kind() == reflect.Float64
if isFloat {
fitsInRegister = tempNumFloats < numOfFloatRegisters()
newNumFloats = tempNumFloats + 1
newNumInts = tempNumInts
} else {
fitsInRegister = tempNumInts < numOfIntegerRegisters()
newNumInts = tempNumInts + 1
newNumFloats = tempNumFloats
}
}
if fitsInRegister {
// Process through normal register allocation
tempNumInts = newNumInts
tempNumFloats = newNumFloats
keepAlive = addValue(val, keepAlive, addInt, addFloat, addStack, pNumInts, pNumFloats, pNumStack)
} else {
// Convert strings to C strings before bundling
if val.Kind() == reflect.String {
ptr := strings.CString(val.String())
keepAlive = append(keepAlive, ptr)
val = reflect.ValueOf(ptr)
args[startIdx+j] = val
}
stackArgs = append(stackArgs, val)
}
}
return stackArgs, keepAlive
}
const (
paddingFieldPrefix = "Pad"
)
// bundleStackArgs bundles remaining arguments for Darwin ARM64 C-style stack packing.
// It creates a packed struct with proper alignment and copies it to the stack in 8-byte chunks.
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
if runtime.GOOS != "darwin" {
panic("purego: bundleStackArgs should only be called on darwin")
}
if len(stackArgs) == 0 {
return
}
// Build struct fields with proper C alignment and padding
var fields []reflect.StructField
currentOffset := uintptr(0)
fieldIndex := 0
for j, val := range stackArgs {
valSize := val.Type().Size()
valAlign := val.Type().Align()
// ARM64 requires 8-byte alignment for 8-byte or larger structs
if val.Kind() == reflect.Struct && valSize >= 8 {
valAlign = 8
}
// Add padding field if needed for alignment
if currentOffset%uintptr(valAlign) != 0 {
paddingNeeded := uintptr(valAlign) - (currentOffset % uintptr(valAlign))
fields = append(fields, reflect.StructField{
Name: paddingFieldPrefix + strconv.Itoa(fieldIndex),
Type: reflect.ArrayOf(int(paddingNeeded), reflect.TypeOf(byte(0))),
})
currentOffset += paddingNeeded
fieldIndex++
}
fields = append(fields, reflect.StructField{
Name: "X" + strconv.Itoa(j),
Type: val.Type(),
})
currentOffset += valSize
fieldIndex++
}
// Create and populate the packed struct
structType := reflect.StructOf(fields)
structInstance := reflect.New(structType).Elem()
// Set values (skip padding fields)
argIndex := 0
for j := 0; j < structInstance.NumField(); j++ {
fieldName := structType.Field(j).Name
if stdstrings.HasPrefix(fieldName, paddingFieldPrefix) {
continue
}
structInstance.Field(j).Set(stackArgs[argIndex])
argIndex++
}
ptr := unsafe.Pointer(structInstance.Addr().Pointer())
size := structType.Size()
copyStruct8ByteChunks(ptr, size, addStack)
}
golang-github-ebitengine-purego-0.10.1/struct_loong64.go 0000664 0000000 0000000 00000012626 15207302613 0023157 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
package purego
import (
"math"
"reflect"
"unsafe"
)
func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 8:
r1 := syscall.a1
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
r1 = syscall.f1
if numFields == 2 {
r1 = syscall.f2<<32 | syscall.f1
}
}
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem()
case outSize <= 16:
r1, r2 := syscall.a1, syscall.a2
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
switch numFields {
case 4:
r1 = syscall.f2<<32 | syscall.f1
r2 = syscall.f4<<32 | syscall.f3
case 3:
r1 = syscall.f2<<32 | syscall.f1
r2 = syscall.f3
case 2:
r1 = syscall.f1
r2 = syscall.f2
default:
panic("unreachable")
}
}
return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem()
default:
// create struct from the Go pointer created above
// weird pointer dereference to circumvent go vet
return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem()
}
}
const (
_NO_CLASS = 0b00
_FLOAT = 0b01
_INT = 0b11
)
func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
if v.Type().Size() == 0 {
return keepAlive
}
if size := v.Type().Size(); size <= 16 {
placeRegisters(v, addFloat, addInt)
} else {
keepAlive = placeStack(v, keepAlive, addInt)
}
return keepAlive // the struct was allocated so don't panic
}
func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
var val uint64
var shift byte
var flushed bool
class := _NO_CLASS
var place func(v reflect.Value)
place = func(v reflect.Value) {
var numFields int
if v.Kind() == reflect.Struct {
numFields = v.Type().NumField()
} else {
numFields = v.Type().Len()
}
for k := 0; k < numFields; k++ {
flushed = false
var f reflect.Value
if v.Kind() == reflect.Struct {
f = v.Field(k)
} else {
f = v.Index(k)
}
align := byte(f.Type().Align()*8 - 1)
shift = (shift + align) &^ align
if shift >= 64 {
shift = 0
flushed = true
if class == _FLOAT {
addFloat(uintptr(val))
} else {
addInt(uintptr(val))
}
}
switch f.Type().Kind() {
case reflect.Struct:
place(f)
case reflect.Bool:
if f.Bool() {
val |= 1 << shift
}
shift += 8
class |= _INT
case reflect.Uint8:
val |= f.Uint() << shift
shift += 8
class |= _INT
case reflect.Uint16:
val |= f.Uint() << shift
shift += 16
class |= _INT
case reflect.Uint32:
val |= f.Uint() << shift
shift += 32
class |= _INT
case reflect.Uint64, reflect.Uint, reflect.Uintptr:
addInt(uintptr(f.Uint()))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Int8:
val |= uint64(f.Int()&0xFF) << shift
shift += 8
class |= _INT
case reflect.Int16:
val |= uint64(f.Int()&0xFFFF) << shift
shift += 16
class |= _INT
case reflect.Int32:
val |= uint64(f.Int()&0xFFFF_FFFF) << shift
shift += 32
class |= _INT
case reflect.Int64, reflect.Int:
addInt(uintptr(f.Int()))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Float32:
if class == _FLOAT {
addFloat(uintptr(val))
val = 0
shift = 0
}
val |= uint64(math.Float32bits(float32(f.Float()))) << shift
shift += 32
class |= _FLOAT
case reflect.Float64:
addFloat(uintptr(math.Float64bits(float64(f.Float()))))
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Ptr, reflect.UnsafePointer:
addInt(f.Pointer())
shift = 0
flushed = true
class = _NO_CLASS
case reflect.Array:
place(f)
default:
panic("purego: unsupported kind " + f.Kind().String())
}
}
}
place(v)
if !flushed {
if class == _FLOAT {
addFloat(uintptr(val))
} else {
addInt(uintptr(val))
}
}
}
func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
// Struct is too big to be placed in registers.
// Copy to heap and place the pointer in register
ptrStruct := reflect.New(v.Type())
ptrStruct.Elem().Set(v)
ptr := ptrStruct.Elem().Addr().UnsafePointer()
keepAlive = append(keepAlive, ptr)
addInt(uintptr(ptr))
return keepAlive
}
// shouldBundleStackArgs always returns false on loong64
// since C-style stack argument bundling is only needed on Darwin ARM64.
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
return false
}
// structFitsInRegisters is not used on loong64.
func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
panic("purego: structFitsInRegisters should not be called on loong64")
}
// collectStackArgs is not used on loong64.
func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
keepAlive []any, addInt, addFloat, addStack func(uintptr),
pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
panic("purego: collectStackArgs should not be called on loong64")
}
// bundleStackArgs is not used on loong64.
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("purego: bundleStackArgs should not be called on loong64")
}
golang-github-ebitengine-purego-0.10.1/struct_ppc64le.go 0000664 0000000 0000000 00000006343 15207302613 0023143 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
package purego
import (
"reflect"
"unsafe"
)
func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 16:
// Reconstruct from registers by copying raw bytes
var buf [16]byte
// Integer registers
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2
}
// Homogeneous float aggregates override integer regs
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
if outType.Field(0).Type.Kind() == reflect.Float32 {
// float32 values in FP regs
f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4}
for i := 0; i < numFields; i++ {
*(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i])
}
} else {
// float64: whole register value is valid
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2
}
}
}
return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem()
default:
// Returned indirectly via pointer in a1
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))
return reflect.NewAt(outType, ptr).Elem()
}
}
func addStruct(
v reflect.Value,
numInts, numFloats, numStack *int,
addInt, addFloat, addStack func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
if size == 0 {
return keepAlive
}
if size <= 16 {
return placeSmallAggregatePPC64LE(v, addFloat, addInt, keepAlive)
}
return placeStack(v, keepAlive, addInt)
}
func placeSmallAggregatePPC64LE(
v reflect.Value,
addFloat, addInt func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
var ptr unsafe.Pointer
if v.CanAddr() {
ptr = v.Addr().UnsafePointer()
} else {
tmp := reflect.New(v.Type())
tmp.Elem().Set(v)
ptr = tmp.UnsafePointer()
keepAlive = append(keepAlive, tmp.Interface())
}
var buf [16]byte
src := unsafe.Slice((*byte)(ptr), size)
copy(buf[:], src)
w0 := *(*uintptr)(unsafe.Pointer(&buf[0]))
w1 := uintptr(0)
if size > 8 {
w1 = *(*uintptr)(unsafe.Pointer(&buf[8]))
}
if isFloats, _ := isAllSameFloat(v.Type()); isFloats {
addFloat(w0)
if size > 8 {
addFloat(w1)
}
} else {
addInt(w0)
if size > 8 {
addInt(w1)
}
}
return keepAlive
}
// placeStack is a fallback for structs that are too large to fit in registers
func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
if v.CanAddr() {
addInt(v.Addr().Pointer())
return keepAlive
}
ptr := reflect.New(v.Type())
ptr.Elem().Set(v)
addInt(ptr.Pointer())
return append(keepAlive, ptr.Interface())
}
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
// PPC64LE does not bundle stack args
return false
}
func collectStackArgs(
args []reflect.Value,
i, numInts, numFloats int,
keepAlive []any,
addInt, addFloat, addStack func(uintptr),
numIntsPtr, numFloatsPtr, numStackPtr *int,
) ([]reflect.Value, []any) {
return nil, keepAlive
}
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("bundleStackArgs not supported on PPC64LE")
}
golang-github-ebitengine-purego-0.10.1/struct_riscv64.go 0000664 0000000 0000000 00000006407 15207302613 0023167 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
package purego
import (
"reflect"
"unsafe"
)
func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 16:
// Reconstruct from registers by copying raw bytes
var buf [16]byte
// Integer registers
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2
}
// Homogeneous float aggregates override integer regs
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
if outType.Field(0).Type.Kind() == reflect.Float32 {
// float32 values are NaN-boxed in FP regs; use low 32 bits only
f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4}
for i := 0; i < numFields; i++ {
*(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i])
}
} else {
// float64: whole register value is valid
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2
}
}
}
return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem()
default:
// Returned indirectly via pointer in a1
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))
return reflect.NewAt(outType, ptr).Elem()
}
}
func addStruct(
v reflect.Value,
numInts, numFloats, numStack *int,
addInt, addFloat, addStack func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
if size == 0 {
return keepAlive
}
if size <= 16 {
return placeSmallAggregateRISCV64(v, addFloat, addInt, keepAlive)
}
return placeStack(v, keepAlive, addInt)
}
func placeSmallAggregateRISCV64(
v reflect.Value,
addFloat, addInt func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
var ptr unsafe.Pointer
if v.CanAddr() {
ptr = v.Addr().UnsafePointer()
} else {
tmp := reflect.New(v.Type())
tmp.Elem().Set(v)
ptr = tmp.UnsafePointer()
keepAlive = append(keepAlive, tmp.Interface())
}
var buf [16]byte
src := unsafe.Slice((*byte)(ptr), size)
copy(buf[:], src)
w0 := *(*uintptr)(unsafe.Pointer(&buf[0]))
w1 := uintptr(0)
if size > 8 {
w1 = *(*uintptr)(unsafe.Pointer(&buf[8]))
}
if isFloats, _ := isAllSameFloat(v.Type()); isFloats {
addFloat(w0)
if size > 8 {
addFloat(w1)
}
} else {
addInt(w0)
if size > 8 {
addInt(w1)
}
}
return keepAlive
}
// placeStack is a fallback for structs that are too large to fit in registers
func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
if v.CanAddr() {
addInt(v.Addr().Pointer())
return keepAlive
}
ptr := reflect.New(v.Type())
ptr.Elem().Set(v)
addInt(ptr.Pointer())
return append(keepAlive, ptr.Interface())
}
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
// RISCV64 does not bundle stack args
return false
}
func collectStackArgs(
args []reflect.Value,
i, numInts, numFloats int,
keepAlive []any,
addInt, addFloat, addStack func(uintptr),
numIntsPtr, numFloatsPtr, numStackPtr *int,
) ([]reflect.Value, []any) {
return nil, keepAlive
}
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("bundleStackArgs not supported on RISCV64")
}
golang-github-ebitengine-purego-0.10.1/struct_s390x.go 0000664 0000000 0000000 00000006333 15207302613 0022553 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
package purego
import (
"reflect"
"unsafe"
)
func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value {
outSize := outType.Size()
switch {
case outSize == 0:
return reflect.New(outType).Elem()
case outSize <= 16:
// Reconstruct from registers by copying raw bytes
var buf [16]byte
// Integer registers
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2
}
// Homogeneous float aggregates override integer regs
if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
if outType.Field(0).Type.Kind() == reflect.Float32 {
// float32 values in FP regs
f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4}
for i := 0; i < numFields; i++ {
*(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i])
}
} else {
// float64: whole register value is valid
*(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1
if outSize > 8 {
*(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2
}
}
}
return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem()
default:
// Returned indirectly via pointer in a1
ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))
return reflect.NewAt(outType, ptr).Elem()
}
}
func addStruct(
v reflect.Value,
numInts, numFloats, numStack *int,
addInt, addFloat, addStack func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
if size == 0 {
return keepAlive
}
if size <= 16 {
return placeSmallAggregateS390X(v, addFloat, addInt, keepAlive)
}
return placeStack(v, keepAlive, addInt)
}
func placeSmallAggregateS390X(
v reflect.Value,
addFloat, addInt func(uintptr),
keepAlive []any,
) []any {
size := v.Type().Size()
var ptr unsafe.Pointer
if v.CanAddr() {
ptr = v.Addr().UnsafePointer()
} else {
tmp := reflect.New(v.Type())
tmp.Elem().Set(v)
ptr = tmp.UnsafePointer()
keepAlive = append(keepAlive, tmp.Interface())
}
var buf [16]byte
src := unsafe.Slice((*byte)(ptr), size)
copy(buf[:], src)
w0 := *(*uintptr)(unsafe.Pointer(&buf[0]))
w1 := uintptr(0)
if size > 8 {
w1 = *(*uintptr)(unsafe.Pointer(&buf[8]))
}
if isFloats, _ := isAllSameFloat(v.Type()); isFloats {
addFloat(w0)
if size > 8 {
addFloat(w1)
}
} else {
addInt(w0)
if size > 8 {
addInt(w1)
}
}
return keepAlive
}
// placeStack is a fallback for structs that are too large to fit in registers
func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
if v.CanAddr() {
addInt(v.Addr().Pointer())
return keepAlive
}
ptr := reflect.New(v.Type())
ptr.Elem().Set(v)
addInt(ptr.Pointer())
return append(keepAlive, ptr.Interface())
}
func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
// S390X does not bundle stack args
return false
}
func collectStackArgs(
args []reflect.Value,
i, numInts, numFloats int,
keepAlive []any,
addInt, addFloat, addStack func(uintptr),
numIntsPtr, numFloatsPtr, numStackPtr *int,
) ([]reflect.Value, []any) {
return nil, keepAlive
}
func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
panic("bundleStackArgs not supported on S390X")
}
golang-github-ebitengine-purego-0.10.1/struct_test.go 0000664 0000000 0000000 00000070017 15207302613 0022644 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
//go:build (darwin || linux) && (amd64 || arm64)
package purego_test
import (
"math"
"os"
"path/filepath"
"runtime"
"testing"
"unsafe"
"github.com/ebitengine/purego"
)
func TestRegisterFunc_structArgs(t *testing.T) {
libFileName := filepath.Join(t.TempDir(), "structtest.so")
t.Logf("Build %v", libFileName)
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "structtest", "struct_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
const (
expectedUnsigned = 0xdeadbeef
expectedSigned = -123
expectedOdd = 12 + 23 + 46
expectedLong uint64 = 0xdeadbeefcafebabe
expectedFloat float32 = 10
expectedDouble float64 = 10
)
{
type Empty struct{}
var NoStruct func(Empty) int64
purego.RegisterLibFunc(&NoStruct, lib, "NoStruct")
if ret := NoStruct(Empty{}); ret != expectedUnsigned {
t.Fatalf("NoStruct returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type EmptyEmpty struct{}
var EmptyEmptyFn func(EmptyEmpty) int64
purego.RegisterLibFunc(&EmptyEmptyFn, lib, "EmptyEmpty")
if ret := EmptyEmptyFn(EmptyEmpty{}); ret != expectedUnsigned {
t.Fatalf("EmptyEmpty returned %#x wanted %#x", ret, expectedUnsigned)
}
var EmptyEmptyWithReg func(uint32, EmptyEmpty, uint32) int64
purego.RegisterLibFunc(&EmptyEmptyWithReg, lib, "EmptyEmptyWithReg")
if ret := EmptyEmptyWithReg(0xdead, EmptyEmpty{}, 0xbeef); ret != expectedUnsigned {
t.Fatalf("EmptyEmptyWithReg returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type GreaterThan16Bytes struct {
x, y, z *int64
}
var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000
var GreaterThan16BytesFn func(GreaterThan16Bytes) int64
purego.RegisterLibFunc(&GreaterThan16BytesFn, lib, "GreaterThan16Bytes")
if ret := GreaterThan16BytesFn(GreaterThan16Bytes{x: &x, y: &y, z: &z}); ret != expectedUnsigned {
t.Fatalf("GreaterThan16Bytes returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type GreaterThan16BytesStruct struct {
a struct {
x, y, z *int64
}
}
var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000
var GreaterThan16BytesStructFn func(GreaterThan16BytesStruct) int64
purego.RegisterLibFunc(&GreaterThan16BytesStructFn, lib, "GreaterThan16BytesStruct")
if ret := GreaterThan16BytesStructFn(GreaterThan16BytesStruct{a: struct{ x, y, z *int64 }{x: &x, y: &y, z: &z}}); ret != expectedUnsigned {
t.Fatalf("GreaterThan16BytesStructFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type GreaterThan16Bytes struct {
x, y, z *int64
}
var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000
var AfterRegisters func(a, b, c, d, e, f, g, h int, bytes GreaterThan16Bytes) int64
purego.RegisterLibFunc(&AfterRegisters, lib, "AfterRegisters")
if ret := AfterRegisters(0xD0000000, 0xE000000, 0xA00000, 0xD0000, 0xB000, 0xE00, 0xE0, 0xF, GreaterThan16Bytes{x: &x, y: &y, z: &z}); ret != expectedUnsigned {
t.Fatalf("AfterRegisters returned %#x wanted %#x", ret, expectedUnsigned)
}
var BeforeRegisters func(bytes GreaterThan16Bytes, a, b int64) uint64
z -= 0xFF
purego.RegisterLibFunc(&BeforeRegisters, lib, "BeforeRegisters")
if ret := BeforeRegisters(GreaterThan16Bytes{&x, &y, &z}, 0x0F, 0xF0); ret != expectedUnsigned {
t.Fatalf("BeforeRegisters returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type IntLessThan16Bytes struct {
x, y int64
}
var IntLessThan16BytesFn func(bytes IntLessThan16Bytes) int64
purego.RegisterLibFunc(&IntLessThan16BytesFn, lib, "IntLessThan16Bytes")
if ret := IntLessThan16BytesFn(IntLessThan16Bytes{0xDEAD0000, 0xBEEF}); ret != expectedUnsigned {
t.Fatalf("IntLessThan16BytesFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type FloatLessThan16Bytes struct {
x, y float32
}
var FloatLessThan16BytesFn func(FloatLessThan16Bytes) float32
purego.RegisterLibFunc(&FloatLessThan16BytesFn, lib, "FloatLessThan16Bytes")
if ret := FloatLessThan16BytesFn(FloatLessThan16Bytes{3, 7}); ret != expectedFloat {
t.Fatalf("FloatLessThan16Bytes returned %f wanted %f", ret, expectedFloat)
}
}
{
type ThreeSmallFields struct {
x, y, z float32
}
var ThreeSmallFieldsFn func(ThreeSmallFields) float32
purego.RegisterLibFunc(&ThreeSmallFieldsFn, lib, "ThreeSmallFields")
if ret := ThreeSmallFieldsFn(ThreeSmallFields{1, 2, 7}); ret != expectedFloat {
t.Fatalf("ThreeSmallFields returned %f wanted %f", ret, expectedFloat)
}
}
{
type FloatAndInt struct {
x float32
y int32
}
var FloatAndIntFn func(FloatAndInt) float32
purego.RegisterLibFunc(&FloatAndIntFn, lib, "FloatAndInt")
if ret := FloatAndIntFn(FloatAndInt{3, 7}); ret != expectedFloat {
t.Fatalf("FloatAndIntFn returned %f wanted %f", ret, expectedFloat)
}
}
{
type DoubleStruct struct {
x float64
}
var DoubleStructFn func(DoubleStruct) float64
purego.RegisterLibFunc(&DoubleStructFn, lib, "DoubleStruct")
if ret := DoubleStructFn(DoubleStruct{10}); ret != expectedDouble {
t.Fatalf("DoubleStruct returned %f wanted %f", ret, expectedDouble)
}
}
{
type TwoDoubleStruct struct {
x, y float64
}
var TwoDoubleStructFn func(TwoDoubleStruct) float64
purego.RegisterLibFunc(&TwoDoubleStructFn, lib, "TwoDoubleStruct")
if ret := TwoDoubleStructFn(TwoDoubleStruct{3, 7}); ret != expectedDouble {
t.Fatalf("TwoDoubleStruct returned %f wanted %f", ret, expectedDouble)
}
}
{
type TwoDoubleTwoStruct struct {
x struct {
x, y float64
}
}
var TwoDoubleTwoStructFn func(TwoDoubleTwoStruct) float64
purego.RegisterLibFunc(&TwoDoubleTwoStructFn, lib, "TwoDoubleTwoStruct")
if ret := TwoDoubleTwoStructFn(TwoDoubleTwoStruct{x: struct{ x, y float64 }{x: 3, y: 7}}); ret != expectedDouble {
t.Fatalf("TwoDoubleTwoStruct returned %f wanted %f", ret, expectedDouble)
}
}
{
type ThreeDoubleStruct struct {
x, y, z float64
}
var ThreeDoubleStructFn func(ThreeDoubleStruct) float64
purego.RegisterLibFunc(&ThreeDoubleStructFn, lib, "ThreeDoubleStruct")
if ret := ThreeDoubleStructFn(ThreeDoubleStruct{1, 3, 6}); ret != expectedDouble {
t.Fatalf("ThreeDoubleStructFn returned %f wanted %f", ret, expectedDouble)
}
}
{
type LargeFloatStruct struct {
a, b, c, d, e, f float64
}
var LargeFloatStructFn func(LargeFloatStruct) float64
purego.RegisterLibFunc(&LargeFloatStructFn, lib, "LargeFloatStruct")
if ret := LargeFloatStructFn(LargeFloatStruct{1, 2, 3, 4, 5, -5}); ret != expectedDouble {
t.Fatalf("LargeFloatStructFn returned %f wanted %f", ret, expectedFloat)
}
var LargeFloatStructWithRegs func(a, b, c float64, s LargeFloatStruct) float64
purego.RegisterLibFunc(&LargeFloatStructWithRegs, lib, "LargeFloatStructWithRegs")
if ret := LargeFloatStructWithRegs(1, -1, 0, LargeFloatStruct{1, 2, 3, 4, 5, -5}); ret != expectedDouble {
t.Fatalf("LargeFloatStructWithRegs returned %f wanted %f", ret, expectedFloat)
}
}
{
type Rect struct {
x, y, w, h float64
}
var RectangleWithRegs func(a, b, c, d, e float64, rect Rect) float64
purego.RegisterLibFunc(&RectangleWithRegs, lib, "RectangleWithRegs")
if ret := RectangleWithRegs(1, 2, 3, 4, -2, Rect{1, 2, 3, -4}); ret != expectedDouble {
t.Fatalf("RectangleWithRegs returned %f wanted %f", ret, expectedDouble)
}
var RectangleSubtract func(rect Rect) float64
purego.RegisterLibFunc(&RectangleSubtract, lib, "RectangleSubtract")
if ret := RectangleSubtract(Rect{15, 5, 3, 7}); ret != expectedDouble {
t.Fatalf("RectangleSubtract returned %f wanted %f", ret, expectedDouble)
}
var Rectangle func(rect Rect) float64
purego.RegisterLibFunc(&Rectangle, lib, "Rectangle")
if ret := Rectangle(Rect{1, 2, 3, 4}); ret != expectedDouble {
t.Fatalf("Rectangle returned %f wanted %f", ret, expectedFloat)
}
}
{
type FloatArray struct {
a [2]float64
}
var FloatArrayFn func(rect FloatArray) float64
purego.RegisterLibFunc(&FloatArrayFn, lib, "FloatArray")
if ret := FloatArrayFn(FloatArray{a: [2]float64{3, 7}}); ret != expectedDouble {
t.Fatalf("FloatArray returned %f wanted %f", ret, expectedFloat)
}
}
{
type UnsignedChar4Bytes struct {
a, b, c, d byte
}
var UnsignedChar4BytesFn func(UnsignedChar4Bytes) uint32
purego.RegisterLibFunc(&UnsignedChar4BytesFn, lib, "UnsignedChar4Bytes")
if ret := UnsignedChar4BytesFn(UnsignedChar4Bytes{a: 0xDE, b: 0xAD, c: 0xBE, d: 0xEF}); ret != expectedUnsigned {
t.Fatalf("UnsignedChar4BytesFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type UnsignedChar4BytesStruct struct {
x struct {
a byte
}
y struct {
b byte
}
z struct {
c byte
}
w struct {
d byte
}
}
var UnsignedChar4BytesStructFn func(UnsignedChar4BytesStruct) uint32
purego.RegisterLibFunc(&UnsignedChar4BytesStructFn, lib, "UnsignedChar4BytesStruct")
if ret := UnsignedChar4BytesStructFn(UnsignedChar4BytesStruct{
x: struct{ a byte }{a: 0xDE},
y: struct{ b byte }{b: 0xAD},
z: struct{ c byte }{c: 0xBE},
w: struct{ d byte }{d: 0xEF},
}); ret != expectedUnsigned {
t.Fatalf("UnsignedChar4BytesStructFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type Short struct {
a, b, c, d uint16
}
var ShortFn func(Short) uint64
purego.RegisterLibFunc(&ShortFn, lib, "Short")
if ret := ShortFn(Short{a: 0xDEAD, b: 0xBEEF, c: 0xCAFE, d: 0xBABE}); ret != expectedLong {
t.Fatalf("ShortFn returned %#x wanted %#x", ret, expectedLong)
}
}
{
type Int struct {
a, b uint32
}
var IntFn func(Int) uint64
purego.RegisterLibFunc(&IntFn, lib, "Int")
if ret := IntFn(Int{a: 0xDEADBEEF, b: 0xCAFEBABE}); ret != expectedLong {
t.Fatalf("IntFn returned %#x wanted %#x", ret, expectedLong)
}
}
{
type Long struct {
a uint64
}
var LongFn func(Long) uint64
purego.RegisterLibFunc(&LongFn, lib, "Long")
if ret := LongFn(Long{a: 0xDEADBEEFCAFEBABE}); ret != expectedLong {
t.Fatalf("LongFn returned %#x wanted %#x", ret, expectedLong)
}
}
{
type Char8Bytes struct {
a, b, c, d, e, f, g, h int8
}
var Char8BytesFn func(Char8Bytes) int32
purego.RegisterLibFunc(&Char8BytesFn, lib, "Char8Bytes")
if ret := Char8BytesFn(Char8Bytes{a: -128, b: 127, c: 3, d: -88, e: -3, f: 34, g: -48, h: -20}); ret != expectedSigned {
t.Fatalf("Char8Bytes returned %d wanted %d", ret, expectedSigned)
}
}
{
type Odd struct {
a, b, c byte
}
var OddFn func(Odd) int32
purego.RegisterLibFunc(&OddFn, lib, "Odd")
if ret := OddFn(Odd{a: 12, b: 23, c: 46}); ret != expectedOdd {
t.Fatalf("OddFn returned %d wanted %d", ret, expectedOdd)
}
}
{
type Char2Short1 struct {
a, b byte
c uint16
}
var Char2Short1s func(Char2Short1) int32
purego.RegisterLibFunc(&Char2Short1s, lib, "Char2Short1s")
if ret := Char2Short1s(Char2Short1{a: 12, b: 23, c: 46}); ret != expectedOdd {
t.Fatalf("Char2Short1s returned %d wanted %d", ret, expectedOdd)
}
}
{
type SignedChar2Short1 struct {
a, b int8
c int16
}
var SignedChar2Short1Fn func(SignedChar2Short1) int32
purego.RegisterLibFunc(&SignedChar2Short1Fn, lib, "SignedChar2Short1")
if ret := SignedChar2Short1Fn(SignedChar2Short1{a: 100, b: -23, c: -200}); ret != expectedSigned {
t.Fatalf("SignedChar2Short1Fn returned %d wanted %d", ret, expectedSigned)
}
}
{
type Array4UnsignedChars struct {
a [4]uint8
}
var Array4UnsignedCharsFn func(chars Array4UnsignedChars) uint32
purego.RegisterLibFunc(&Array4UnsignedCharsFn, lib, "Array4UnsignedChars")
if ret := Array4UnsignedCharsFn(Array4UnsignedChars{a: [...]uint8{0xDE, 0xAD, 0xBE, 0xEF}}); ret != expectedUnsigned {
t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type Array3UnsignedChar struct {
a [3]uint8
}
var Array3UnsignedChars func(chars Array3UnsignedChar) uint32
purego.RegisterLibFunc(&Array3UnsignedChars, lib, "Array3UnsignedChars")
if ret := Array3UnsignedChars(Array3UnsignedChar{a: [...]uint8{0xDE, 0xAD, 0xBE}}); ret != expectedUnsigned {
t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type Array2UnsignedShort struct {
a [2]uint16
}
var Array2UnsignedShorts func(chars Array2UnsignedShort) uint32
purego.RegisterLibFunc(&Array2UnsignedShorts, lib, "Array2UnsignedShorts")
if ret := Array2UnsignedShorts(Array2UnsignedShort{a: [...]uint16{0xDEAD, 0xBEEF}}); ret != expectedUnsigned {
t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned)
}
}
{
type Array4Chars struct {
a [4]int8
}
var Array4CharsFn func(chars Array4Chars) int32
purego.RegisterLibFunc(&Array4CharsFn, lib, "Array4Chars")
const expectedSum = 10 + 20 + 30 + 63
if ret := Array4CharsFn(Array4Chars{a: [...]int8{10, 20, 30, 63}}); ret != expectedSum {
t.Fatalf("Array4CharsFn returned %d wanted %d", ret, expectedSum)
}
}
{
type Array2Short struct {
a [2]int16
}
var Array2Shorts func(chars Array2Short) int32
purego.RegisterLibFunc(&Array2Shorts, lib, "Array2Shorts")
if ret := Array2Shorts(Array2Short{a: [...]int16{-333, 210}}); ret != expectedSigned {
t.Fatalf("Array4Shorts returned %#x wanted %#x", ret, expectedSigned)
}
}
{
type Array3Short struct {
a [3]int16
}
var Array3Shorts func(chars Array3Short) int32
purego.RegisterLibFunc(&Array3Shorts, lib, "Array3Shorts")
if ret := Array3Shorts(Array3Short{a: [...]int16{-333, 100, 110}}); ret != expectedSigned {
t.Fatalf("Array4Shorts returned %#x wanted %#x", ret, expectedSigned)
}
}
{
type BoolStruct struct {
b bool
}
var BoolStructFn func(BoolStruct) bool
purego.RegisterLibFunc(&BoolStructFn, lib, "BoolStruct")
if ret := BoolStructFn(BoolStruct{true}); ret != true {
t.Fatalf("BoolStructFn returned %v wanted %v", ret, true)
}
if ret := BoolStructFn(BoolStruct{false}); ret != false {
t.Fatalf("BoolStructFn returned %v wanted %v", ret, false)
}
}
{
type BoolFloat struct {
b bool
_ [3]byte // purego won't do padding for you so make sure it aligns properly with C struct
f float32
}
var BoolFloatFn func(BoolFloat) float32
purego.RegisterLibFunc(&BoolFloatFn, lib, "BoolFloat")
if ret := BoolFloatFn(BoolFloat{b: true, f: 10}); ret != expectedFloat {
t.Fatalf("BoolFloatFn returned %f wanted %f", ret, expectedFloat)
}
if ret := BoolFloatFn(BoolFloat{b: false, f: 10}); ret != -expectedFloat {
t.Fatalf("BoolFloatFn returned %f wanted %f", ret, -expectedFloat)
}
}
{
type point struct{ x, y float64 }
type size struct{ width, height float64 }
type Content struct {
point point
size size
}
var InitWithContentRect func(*int, Content, int32, int32, bool) uint64
purego.RegisterLibFunc(&InitWithContentRect, lib, "InitWithContentRect")
if ret := InitWithContentRect(new(int),
// These numbers are created so that when added together and then divided by 11 it produces 0xdeadbeef
Content{point{x: 41_000_000_000, y: 95_000_000}, size{width: 214_000, height: 149}},
15, 4, true); ret != expectedUnsigned {
t.Fatalf("InitWithContentRect returned %d wanted %#x", ret, expectedUnsigned)
}
}
{
type GoInt4 struct {
A, B, C, D int
}
var GoInt4Fn func(GoInt4) int
purego.RegisterLibFunc(&GoInt4Fn, lib, "GoInt4")
const expected = math.MaxInt - 52 - 3 + 4
if ret := GoInt4Fn(GoInt4{math.MaxInt, -52, 3, 4}); ret != expected {
t.Fatalf("GoInt4Fn returned %d wanted %#x", ret, expected)
}
}
{
type GoUint4 struct {
A, B, C, D uint
}
var GoUint4Fn func(GoUint4) uint
purego.RegisterLibFunc(&GoUint4Fn, lib, "GoUint4")
const expected = 1_000_000 + 53 + 71 + 8
if ret := GoUint4Fn(GoUint4{1_000_000, 53, 71, 8}); ret != expected {
t.Fatalf("GoUint4Fn returned %d wanted %#x", ret, expected)
}
}
{
type OneLong struct{ a uintptr }
var TakeGoUintAndReturn func(a OneLong) uint64
purego.RegisterLibFunc(&TakeGoUintAndReturn, lib, "TakeGoUintAndReturn")
expected := uint64(7)
if ret := TakeGoUintAndReturn(OneLong{7}); ret != expected {
t.Fatalf("TakeGoUintAndReturn returned %+v wanted %+v", ret, expected)
}
}
{
type FloatAndBool struct {
x float32
y bool
}
var FloatAndBoolFn func(FloatAndBool) int32
purego.RegisterLibFunc(&FloatAndBoolFn, lib, "FloatAndBool")
if ret := FloatAndBoolFn(FloatAndBool{x: 12345.0, y: true}); ret != 1 {
t.Fatalf("FloatAndBool(y: true) = %d, want 1", ret)
}
if ret := FloatAndBoolFn(FloatAndBool{x: 12345.0, y: false}); ret != 0 {
t.Fatalf("FloatAndBool(y: false) = %d, want 0", ret)
}
}
{
type FourInt32s struct {
f0, f1, f2, f3 int32
}
var FourInt32sFn func(FourInt32s) int32
purego.RegisterLibFunc(&FourInt32sFn, lib, "FourInt32s")
result := FourInt32sFn(FourInt32s{100, -127, 4, -100})
const want = 100 - 127 + 4 - 100
if result != want {
t.Fatalf("FourInt32s returned %d wanted %d", result, want)
}
}
{
type PointerWrapper struct {
ctx unsafe.Pointer
}
var ExtractPointer func(wrapper PointerWrapper) uintptr
purego.RegisterLibFunc(&ExtractPointer, lib, "ExtractPointer")
var v int
ptr := unsafe.Pointer(&v)
expected := uintptr(ptr)
result := ExtractPointer(PointerWrapper{ctx: ptr})
if result != expected {
t.Fatalf("ExtractPointer returned %#x wanted %#x", result, expected)
}
}
{
type TwoPointers struct {
ptr1, ptr2 unsafe.Pointer
}
var AddPointers func(wrapper TwoPointers) uintptr
purego.RegisterLibFunc(&AddPointers, lib, "AddPointers")
var v1, v2 int
ptr1 := unsafe.Pointer(&v1)
ptr2 := unsafe.Pointer(&v2)
expected := uintptr(ptr1) + uintptr(ptr2)
result := AddPointers(TwoPointers{ptr1, ptr2})
if result != expected {
t.Fatalf("AddPointers returned %#x wanted %#x", result, expected)
}
}
}
func TestRegisterFunc_structReturns(t *testing.T) {
libFileName := filepath.Join(t.TempDir(), "structreturntest.so")
t.Logf("Build %v", libFileName)
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "structtest", "structreturn_test.c")); err != nil {
t.Fatal(err)
}
defer os.Remove(libFileName)
lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
if err != nil {
t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
}
{
type Empty struct{}
var ReturnEmpty func() Empty
purego.RegisterLibFunc(&ReturnEmpty, lib, "ReturnEmpty")
ret := ReturnEmpty()
_ = ret
}
{
type inner struct{ a int16 }
type StructInStruct struct {
a inner
b inner
c inner
}
var ReturnStructInStruct func(a, b, c int16) StructInStruct
purego.RegisterLibFunc(&ReturnStructInStruct, lib, "ReturnStructInStruct")
expected := StructInStruct{inner{^int16(0)}, inner{2}, inner{3}}
if ret := ReturnStructInStruct(^int16(0), 2, 3); ret != expected {
t.Fatalf("StructInStruct returned %+v wanted %+v", ret, expected)
}
}
{
type ThreeShorts struct{ a, b, c int16 }
var ReturnThreeShorts func(a, b, c int16) ThreeShorts
purego.RegisterLibFunc(&ReturnThreeShorts, lib, "ReturnThreeShorts")
expected := ThreeShorts{^int16(0), 2, 3}
if ret := ReturnThreeShorts(^int16(0), 2, 3); ret != expected {
t.Fatalf("ReturnThreeShorts returned %+v wanted %+v", ret, expected)
}
}
{
type FourShorts struct{ a, b, c, d int16 }
var ReturnFourShorts func(a, b, c, d int16) FourShorts
purego.RegisterLibFunc(&ReturnFourShorts, lib, "ReturnFourShorts")
expected := FourShorts{^int16(0), 2, 3, 4}
if ret := ReturnFourShorts(^int16(0), 2, 3, 4); ret != expected {
t.Fatalf("ReturnFourShorts returned %+v wanted %+v", ret, expected)
}
}
{
type OneLong struct{ a int64 }
var ReturnOneLong func(a int64) OneLong
purego.RegisterLibFunc(&ReturnOneLong, lib, "ReturnOneLong")
expected := OneLong{5}
if ret := ReturnOneLong(5); ret != expected {
t.Fatalf("ReturnOneLong returned %+v wanted %+v", ret, expected)
}
}
{
type TwoLongs struct{ a, b int64 }
var ReturnTwoLongs func(a, b int64) TwoLongs
purego.RegisterLibFunc(&ReturnTwoLongs, lib, "ReturnTwoLongs")
expected := TwoLongs{1, 2}
if ret := ReturnTwoLongs(1, 2); ret != expected {
t.Fatalf("ReturnTwoLongs returned %+v wanted %+v", ret, expected)
}
}
{
type ThreeLongs struct{ a, b, c int64 }
var ReturnThreeLongs func(a, b, c int64) ThreeLongs
purego.RegisterLibFunc(&ReturnThreeLongs, lib, "ReturnThreeLongs")
expected := ThreeLongs{1, 2, 3}
if ret := ReturnThreeLongs(1, 2, 3); ret != expected {
t.Fatalf("ReturnThreeLongs returned %+v wanted %+v", ret, expected)
}
}
{
type OneFloat struct{ a float32 }
var ReturnOneFloat func(a float32) OneFloat
purego.RegisterLibFunc(&ReturnOneFloat, lib, "ReturnOneFloat")
expected := OneFloat{1}
if ret := ReturnOneFloat(1); ret != expected {
t.Fatalf("ReturnOneFloat returned %+v wanted %+v", ret, expected)
}
}
{
type TwoFloats struct{ a, b float32 }
var ReturnTwoFloats func(a, b float32) TwoFloats
purego.RegisterLibFunc(&ReturnTwoFloats, lib, "ReturnTwoFloats")
expected := TwoFloats{3, 10}
if ret := ReturnTwoFloats(5, 2); ret != expected {
t.Fatalf("ReturnTwoFloats returned %+v wanted %+v", ret, expected)
}
}
{
type ThreeFloats struct{ a, b, c float32 }
var ReturnThreeFloats func(a, b, c float32) ThreeFloats
purego.RegisterLibFunc(&ReturnThreeFloats, lib, "ReturnThreeFloats")
expected := ThreeFloats{1, 2, 3}
if ret := ReturnThreeFloats(1, 2, 3); ret != expected {
t.Fatalf("ReturnThreeFloats returned %+v wanted %+v", ret, expected)
}
}
{
type OneDouble struct{ a float64 }
var ReturnOneDouble func(a float64) OneDouble
purego.RegisterLibFunc(&ReturnOneDouble, lib, "ReturnOneDouble")
expected := OneDouble{1}
if ret := ReturnOneDouble(1); ret != expected {
t.Fatalf("ReturnOneDouble returned %+v wanted %+v", ret, expected)
}
}
{
type TwoDoubles struct{ a, b float64 }
var ReturnTwoDoubles func(a, b float64) TwoDoubles
purego.RegisterLibFunc(&ReturnTwoDoubles, lib, "ReturnTwoDoubles")
expected := TwoDoubles{1, 2}
if ret := ReturnTwoDoubles(1, 2); ret != expected {
t.Fatalf("ReturnTwoDoubles returned %+v wanted %+v", ret, expected)
}
}
{
type ThreeDoubles struct{ a, b, c float64 }
var ReturnThreeDoubles func(a, b, c float64) ThreeDoubles
purego.RegisterLibFunc(&ReturnThreeDoubles, lib, "ReturnThreeDoubles")
expected := ThreeDoubles{1, 2, 3}
if ret := ReturnThreeDoubles(1, 2, 3); ret != expected {
t.Fatalf("ReturnThreeDoubles returned %+v wanted %+v", ret, expected)
}
}
{
type FourDoubles struct{ a, b, c, d float64 }
var ReturnFourDoubles func(a, b, c, d float64) FourDoubles
purego.RegisterLibFunc(&ReturnFourDoubles, lib, "ReturnFourDoubles")
expected := FourDoubles{1, 2, 3, 4}
if ret := ReturnFourDoubles(1, 2, 3, 4); ret != expected {
t.Fatalf("ReturnFourDoubles returned %+v wanted %+v", ret, expected)
}
}
{
type FourDoublesInternal struct {
f struct{ a, b float64 }
g struct{ c, d float64 }
}
var ReturnFourDoublesInternal func(a, b, c, d float64) FourDoublesInternal
purego.RegisterLibFunc(&ReturnFourDoublesInternal, lib, "ReturnFourDoublesInternal")
expected := FourDoublesInternal{f: struct{ a, b float64 }{a: 1, b: 2}, g: struct{ c, d float64 }{c: 3, d: 4}}
if ret := ReturnFourDoublesInternal(1, 2, 3, 4); ret != expected {
t.Fatalf("ReturnFourDoublesInternal returned %+v wanted %+v", ret, expected)
}
}
{
type FiveDoubles struct{ a, b, c, d, e float64 }
var ReturnFiveDoubles func(a, b, c, d, e float64) FiveDoubles
purego.RegisterLibFunc(&ReturnFiveDoubles, lib, "ReturnFiveDoubles")
expected := FiveDoubles{1, 2, 3, 4, 5}
if ret := ReturnFiveDoubles(1, 2, 3, 4, 5); ret != expected {
t.Fatalf("ReturnFiveDoubles returned %+v wanted %+v", ret, expected)
}
}
{
type OneFloatOneDouble struct {
a float32
_ float32
b float64
}
var ReturnOneFloatOneDouble func(a float32, b float64) OneFloatOneDouble
purego.RegisterLibFunc(&ReturnOneFloatOneDouble, lib, "ReturnOneFloatOneDouble")
expected := OneFloatOneDouble{a: 1, b: 2}
if ret := ReturnOneFloatOneDouble(1, 2); ret != expected {
t.Fatalf("ReturnOneFloatOneDouble returned %+v wanted %+v", ret, expected)
}
}
{
type OneDoubleOneFloat struct {
a float64
b float32
}
var ReturnOneDoubleOneFloat func(a float64, b float32) OneDoubleOneFloat
purego.RegisterLibFunc(&ReturnOneDoubleOneFloat, lib, "ReturnOneDoubleOneFloat")
expected := OneDoubleOneFloat{1, 2}
if ret := ReturnOneDoubleOneFloat(1, 2); ret != expected {
t.Fatalf("ReturnOneDoubleOneFloat returned %+v wanted %+v", ret, expected)
}
}
{
type Unaligned1 struct {
a int8
_ [1]int8
b int16
_ [1]int32
c int64
}
var ReturnUnaligned1 func(a int8, b int16, c int64) Unaligned1
purego.RegisterLibFunc(&ReturnUnaligned1, lib, "ReturnUnaligned1")
expected := Unaligned1{a: 1, b: 2, c: 3}
if ret := ReturnUnaligned1(1, 2, 3); ret != expected {
t.Fatalf("ReturnUnaligned1 returned %+v wanted %+v", ret, expected)
}
}
{
type Mixed1 struct {
a float32
b int32
}
var ReturnMixed1 func(a float32, b int32) Mixed1
purego.RegisterLibFunc(&ReturnMixed1, lib, "ReturnMixed1")
expected := Mixed1{1, 2}
if ret := ReturnMixed1(1, 2); ret != expected {
t.Fatalf("ReturnMixed1 returned %+v wanted %+v", ret, expected)
}
}
{
type Mixed2 struct {
a float32
b int32
c float32
d int32
}
var ReturnMixed2 func(a float32, b int32, c float32, d int32) Mixed2
purego.RegisterLibFunc(&ReturnMixed2, lib, "ReturnMixed2")
expected := Mixed2{1, 2, 3, 4}
if ret := ReturnMixed2(1, 2, 3, 4); ret != expected {
t.Fatalf("ReturnMixed2 returned %+v wanted %+v", ret, expected)
}
}
{
type Mixed3 struct {
a float32
b uint32
c float64
}
var ReturnMixed3 func(a float32, b uint32, c float64) Mixed3
purego.RegisterLibFunc(&ReturnMixed3, lib, "ReturnMixed3")
expected := Mixed3{1, 2, 3}
if ret := ReturnMixed3(1, 2, 3); ret != expected {
t.Fatalf("ReturnMixed3 returned %+v wanted %+v", ret, expected)
}
}
{
type Mixed4 struct {
a float64
b uint32
c float32
}
var ReturnMixed4 func(a float64, b uint32, c float32) Mixed4
purego.RegisterLibFunc(&ReturnMixed4, lib, "ReturnMixed4")
expected := Mixed4{1, 2, 3}
if ret := ReturnMixed4(1, 2, 3); ret != expected {
t.Fatalf("ReturnMixed4 returned %+v wanted %+v", ret, expected)
}
}
{
type Mixed5 struct {
a *int64
b int32
c float32
d int32
}
var ReturnMixed5 func(a *int64, b int32, c float32, d int32) Mixed5
purego.RegisterLibFunc(&ReturnMixed5, lib, "ReturnMixed5")
ptr := new(int64)
expected := Mixed5{ptr, 1, 7.2, 9}
if ret := ReturnMixed5(ptr, 1, 7.2, 9); ret != expected {
t.Fatalf("ReturnMixed5 returned %+v wanted %+v", ret, expected)
}
runtime.KeepAlive(ptr)
}
{
type Mixed5 struct {
a *int64
b int32
c float32
d int32
}
var IdentityMixed5 func(m Mixed5) Mixed5
purego.RegisterLibFunc(&IdentityMixed5, lib, "IdentityMixed5")
ptr := new(int64)
expected := Mixed5{ptr, 1, 7.2, 9}
if ret := IdentityMixed5(expected); ret != expected {
t.Fatalf("IdentityMixed5 returned %+v wanted %+v", ret, expected)
}
runtime.KeepAlive(ptr)
}
{
type SmallBool struct {
a bool
b int32
c int64
}
var ReturnSmallBool func(a bool, b int32, c int64) SmallBool
purego.RegisterLibFunc(&ReturnSmallBool, lib, "ReturnSmallBool")
expected := SmallBool{true, 42, 123456789}
if ret := ReturnSmallBool(true, 42, 123456789); ret != expected {
t.Fatalf("ReturnSmallBool returned %+v wanted %+v", ret, expected)
}
}
{
type LargeBool struct {
a bool
b int32
c int64
d int64
}
var ReturnLargeBool func(a bool, b int32, c int64, d int64) LargeBool
purego.RegisterLibFunc(&ReturnLargeBool, lib, "ReturnLargeBool")
expected := LargeBool{false, -99, 987654321, 111222333444}
if ret := ReturnLargeBool(false, -99, 987654321, 111222333444); ret != expected {
t.Fatalf("ReturnLargeBool returned %+v wanted %+v", ret, expected)
}
}
{
type Ptr1 struct {
a *int64
b unsafe.Pointer
}
var ReturnPtr1 func(a *int64, b unsafe.Pointer) Ptr1
purego.RegisterLibFunc(&ReturnPtr1, lib, "ReturnPtr1")
a, b := new(int64), new(struct{})
expected := Ptr1{a, unsafe.Pointer(b)}
if ret := ReturnPtr1(a, unsafe.Pointer(b)); ret != expected {
t.Fatalf("ReturnPtr1 returned %+v wanted %+v", ret, expected)
}
runtime.KeepAlive(a)
runtime.KeepAlive(b)
}
}
golang-github-ebitengine-purego-0.10.1/sys_386.s 0000664 0000000 0000000 00000007355 15207302613 0021341 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#define STACK_SIZE 160
#define PTR_ADDRESS (STACK_SIZE - 4)
// syscall15X calls a function in libc on behalf of the syscall package.
// syscall15X takes a pointer to a struct like:
// struct {
// fn uintptr
// a1 uintptr
// ...
// a32 uintptr
// f1 uintptr
// ...
// f16 uintptr
// arm64_r8 uintptr
// }
// syscall15X must be called on the g0 stack with the
// C calling convention (use libcCall).
//
// On i386 System V ABI, all arguments are passed on the stack.
// Return value is in EAX (and EDX for 64-bit values).
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $4
DATA ·syscall15XABI0(SB)/4, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0-0
// Called via C calling convention: argument pointer at 4(SP)
// NOT via Go calling convention
// On i386, the first argument is at 4(SP) after CALL pushes return address
MOVL 4(SP), AX // get pointer to syscall15Args
// Save callee-saved registers
PUSHL BP
PUSHL BX
PUSHL SI
PUSHL DI
MOVL AX, BX // save args pointer in BX
// Allocate stack space for C function arguments
// i386 SysV: all 32 args on stack = 32 * 4 = 128 bytes
// Plus 16 bytes for alignment and local storage
SUBL $STACK_SIZE, SP
MOVL BX, PTR_ADDRESS(SP) // save args pointer
// Load function pointer
MOVL syscall15Args_fn(BX), AX
MOVL AX, (PTR_ADDRESS-4)(SP) // save fn pointer
// Push all integer arguments onto the stack (a1-a32)
// i386 SysV ABI: arguments pushed right-to-left, but we're
// setting up the stack from low to high addresses
MOVL syscall15Args_a1(BX), AX
MOVL AX, 0(SP)
MOVL syscall15Args_a2(BX), AX
MOVL AX, 4(SP)
MOVL syscall15Args_a3(BX), AX
MOVL AX, 8(SP)
MOVL syscall15Args_a4(BX), AX
MOVL AX, 12(SP)
MOVL syscall15Args_a5(BX), AX
MOVL AX, 16(SP)
MOVL syscall15Args_a6(BX), AX
MOVL AX, 20(SP)
MOVL syscall15Args_a7(BX), AX
MOVL AX, 24(SP)
MOVL syscall15Args_a8(BX), AX
MOVL AX, 28(SP)
MOVL syscall15Args_a9(BX), AX
MOVL AX, 32(SP)
MOVL syscall15Args_a10(BX), AX
MOVL AX, 36(SP)
MOVL syscall15Args_a11(BX), AX
MOVL AX, 40(SP)
MOVL syscall15Args_a12(BX), AX
MOVL AX, 44(SP)
MOVL syscall15Args_a13(BX), AX
MOVL AX, 48(SP)
MOVL syscall15Args_a14(BX), AX
MOVL AX, 52(SP)
MOVL syscall15Args_a15(BX), AX
MOVL AX, 56(SP)
MOVL syscall15Args_a16(BX), AX
MOVL AX, 60(SP)
MOVL syscall15Args_a17(BX), AX
MOVL AX, 64(SP)
MOVL syscall15Args_a18(BX), AX
MOVL AX, 68(SP)
MOVL syscall15Args_a19(BX), AX
MOVL AX, 72(SP)
MOVL syscall15Args_a20(BX), AX
MOVL AX, 76(SP)
MOVL syscall15Args_a21(BX), AX
MOVL AX, 80(SP)
MOVL syscall15Args_a22(BX), AX
MOVL AX, 84(SP)
MOVL syscall15Args_a23(BX), AX
MOVL AX, 88(SP)
MOVL syscall15Args_a24(BX), AX
MOVL AX, 92(SP)
MOVL syscall15Args_a25(BX), AX
MOVL AX, 96(SP)
MOVL syscall15Args_a26(BX), AX
MOVL AX, 100(SP)
MOVL syscall15Args_a27(BX), AX
MOVL AX, 104(SP)
MOVL syscall15Args_a28(BX), AX
MOVL AX, 108(SP)
MOVL syscall15Args_a29(BX), AX
MOVL AX, 112(SP)
MOVL syscall15Args_a30(BX), AX
MOVL AX, 116(SP)
MOVL syscall15Args_a31(BX), AX
MOVL AX, 120(SP)
MOVL syscall15Args_a32(BX), AX
MOVL AX, 124(SP)
// Call the C function
MOVL (PTR_ADDRESS-4)(SP), AX
CALL AX
// Get args pointer back and save results
MOVL PTR_ADDRESS(SP), BX
MOVL AX, syscall15Args_a1(BX) // return value r1
MOVL DX, syscall15Args_a2(BX) // return value r2 (for 64-bit returns)
// Save x87 FPU return value (ST0) to f1 field
// On i386 System V ABI, float/double returns are in ST(0)
// We save as float64 (8 bytes) to preserve precision
FMOVDP F0, syscall15Args_f1(BX)
// Clean up stack
ADDL $STACK_SIZE, SP
// Restore callee-saved registers
POPL DI
POPL SI
POPL BX
POPL BP
RET
golang-github-ebitengine-purego-0.10.1/sys_amd64.s 0000664 0000000 0000000 00000012150 15207302613 0021721 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd
#include "textflag.h"
#include "abi_amd64.h"
#include "go_asm.h"
#include "funcdata.h"
#define STACK_SIZE 80
#define PTR_ADDRESS (STACK_SIZE - 8)
// syscall15X calls a function in libc on behalf of the syscall package.
// syscall15X takes a pointer to a struct like:
// struct {
// fn uintptr
// a1 uintptr
// a2 uintptr
// a3 uintptr
// a4 uintptr
// a5 uintptr
// a6 uintptr
// a7 uintptr
// a8 uintptr
// a9 uintptr
// a10 uintptr
// a11 uintptr
// a12 uintptr
// a13 uintptr
// a14 uintptr
// a15 uintptr
// r1 uintptr
// r2 uintptr
// err uintptr
// }
// syscall15X must be called on the g0 stack with the
// C calling convention (use libcCall).
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0
PUSHQ BP
MOVQ SP, BP
SUBQ $STACK_SIZE, SP
MOVQ DI, PTR_ADDRESS(BP) // save the pointer
MOVQ DI, R11
MOVQ syscall15Args_f1(R11), X0 // f1
MOVQ syscall15Args_f2(R11), X1 // f2
MOVQ syscall15Args_f3(R11), X2 // f3
MOVQ syscall15Args_f4(R11), X3 // f4
MOVQ syscall15Args_f5(R11), X4 // f5
MOVQ syscall15Args_f6(R11), X5 // f6
MOVQ syscall15Args_f7(R11), X6 // f7
MOVQ syscall15Args_f8(R11), X7 // f8
MOVQ syscall15Args_a1(R11), DI // a1
MOVQ syscall15Args_a2(R11), SI // a2
MOVQ syscall15Args_a3(R11), DX // a3
MOVQ syscall15Args_a4(R11), CX // a4
MOVQ syscall15Args_a5(R11), R8 // a5
MOVQ syscall15Args_a6(R11), R9 // a6
// push the remaining paramters onto the stack
MOVQ syscall15Args_a7(R11), R12
MOVQ R12, 0(SP) // push a7
MOVQ syscall15Args_a8(R11), R12
MOVQ R12, 8(SP) // push a8
MOVQ syscall15Args_a9(R11), R12
MOVQ R12, 16(SP) // push a9
MOVQ syscall15Args_a10(R11), R12
MOVQ R12, 24(SP) // push a10
MOVQ syscall15Args_a11(R11), R12
MOVQ R12, 32(SP) // push a11
MOVQ syscall15Args_a12(R11), R12
MOVQ R12, 40(SP) // push a12
MOVQ syscall15Args_a13(R11), R12
MOVQ R12, 48(SP) // push a13
MOVQ syscall15Args_a14(R11), R12
MOVQ R12, 56(SP) // push a14
MOVQ syscall15Args_a15(R11), R12
MOVQ R12, 64(SP) // push a15
XORL AX, AX // vararg: say "no float args"
MOVQ syscall15Args_fn(R11), R10 // fn
CALL R10
MOVQ PTR_ADDRESS(BP), DI // get the pointer back
MOVQ AX, syscall15Args_a1(DI) // r1
MOVQ DX, syscall15Args_a2(DI) // r3
MOVQ X0, syscall15Args_f1(DI) // f1
MOVQ X1, syscall15Args_f2(DI) // f2
#ifdef GOOS_darwin
CALL purego_error(SB)
MOVD (AX), AX
MOVD AX, syscall15Args_a3(DI) // save errno
#endif
XORL AX, AX // no error (it's ignored anyway)
ADDQ $STACK_SIZE, SP
MOVQ BP, SP
POPQ BP
RET
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
MOVQ 0(SP), AX // save the return address to calculate the cb index
MOVQ 8(SP), R10 // get the return SP so that we can align register args with stack args
ADDQ $8, SP // remove return address from stack, we are not returning to callbackasm, but to its caller.
// make space for first six int and 8 float arguments below the frame
ADJSP $14*8, SP
MOVSD X0, (1*8)(SP)
MOVSD X1, (2*8)(SP)
MOVSD X2, (3*8)(SP)
MOVSD X3, (4*8)(SP)
MOVSD X4, (5*8)(SP)
MOVSD X5, (6*8)(SP)
MOVSD X6, (7*8)(SP)
MOVSD X7, (8*8)(SP)
MOVQ DI, (9*8)(SP)
MOVQ SI, (10*8)(SP)
MOVQ DX, (11*8)(SP)
MOVQ CX, (12*8)(SP)
MOVQ R8, (13*8)(SP)
MOVQ R9, (14*8)(SP)
LEAQ 8(SP), R8 // R8 = address of args vector
PUSHQ R10 // push the stack pointer below registers
// Switch from the host ABI to the Go ABI.
PUSH_REGS_HOST_TO_ABI0()
// determine index into runtime·cbs table
MOVQ $callbackasm(SB), DX
SUBQ DX, AX
MOVQ $0, DX
MOVQ $5, CX // divide by 5 because each call instruction in ·callbacks is 5 bytes long
DIVL CX
SUBQ $1, AX // subtract 1 because return PC is to the next slot
// Create a struct callbackArgs on our stack to be passed as
// the "frame" to cgocallback and on to callbackWrap.
// $24 to make enough room for the arguments to runtime.cgocallback
SUBQ $(24+callbackArgs__size), SP
MOVQ AX, (24+callbackArgs_index)(SP) // callback index
MOVQ R8, (24+callbackArgs_args)(SP) // address of args vector
MOVQ $0, (24+callbackArgs_result)(SP) // result
LEAQ 24(SP), AX // take the address of callbackArgs
// Call cgocallback, which will call callbackWrap(frame).
MOVQ ·callbackWrap_call(SB), DI // Get the ABIInternal function pointer
MOVQ (DI), DI // without by using a closure.
MOVQ AX, SI // frame (address of callbackArgs)
MOVQ $0, CX // context
CALL crosscall2(SB) // runtime.cgocallback(fn, frame, ctxt uintptr)
// Get callback result.
MOVQ (24+callbackArgs_result)(SP), AX
ADDQ $(24+callbackArgs__size), SP // remove callbackArgs struct
POP_REGS_HOST_TO_ABI0()
POPQ R10 // get the SP back
ADJSP $-14*8, SP // remove arguments
MOVQ R10, 0(SP)
RET
golang-github-ebitengine-purego-0.10.1/sys_arm.s 0000664 0000000 0000000 00000010034 15207302613 0021564 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#define STACK_SIZE 128
#define PTR_ADDRESS (STACK_SIZE - 4)
// syscall15X calls a function in libc on behalf of the syscall package.
// syscall15X takes a pointer to a struct like:
// struct {
// fn uintptr
// a1 uintptr
// ...
// a32 uintptr
// f1 uintptr
// ...
// f16 uintptr
// arm64_r8 uintptr
// }
// syscall15X must be called on the g0 stack with the
// C calling convention (use libcCall).
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $4
DATA ·syscall15XABI0(SB)/4, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0-0
// Called via C calling convention: R0 = pointer to syscall15Args
// NOT via Go calling convention
// Save link register and callee-saved registers first
MOVW.W R14, -4(R13) // save LR (decrement and store)
MOVM.DB.W [R4, R5, R6, R7, R8, R9, R11], (R13) // save callee-saved regs
MOVW R0, R8
SUB $STACK_SIZE, R13
MOVW R8, PTR_ADDRESS(R13)
// Load function pointer first (before anything can corrupt R8)
MOVW syscall15Args_fn(R8), R5
MOVW R5, (PTR_ADDRESS-4)(R13) // save fn at offset 56
// Load floating point arguments
// Each float64 spans 2 uintptr slots (8 bytes) on ARM32, so we skip by 2
MOVD syscall15Args_f1(R8), F0 // f1+f2 -> D0
MOVD syscall15Args_f3(R8), F1 // f3+f4 -> D1
MOVD syscall15Args_f5(R8), F2 // f5+f6 -> D2
MOVD syscall15Args_f7(R8), F3 // f7+f8 -> D3
MOVD syscall15Args_f9(R8), F4 // f9+f10 -> D4
MOVD syscall15Args_f11(R8), F5 // f11+f12 -> D5
MOVD syscall15Args_f13(R8), F6 // f13+f14 -> D6
MOVD syscall15Args_f15(R8), F7 // f15+f16 -> D7
// Load integer arguments into registers (R0-R3 for ARM EABI)
MOVW syscall15Args_a1(R8), R0 // a1
MOVW syscall15Args_a2(R8), R1 // a2
MOVW syscall15Args_a3(R8), R2 // a3
MOVW syscall15Args_a4(R8), R3 // a4
// push a5-a32 onto stack
MOVW syscall15Args_a5(R8), R4
MOVW R4, 0(R13)
MOVW syscall15Args_a6(R8), R4
MOVW R4, 4(R13)
MOVW syscall15Args_a7(R8), R4
MOVW R4, 8(R13)
MOVW syscall15Args_a8(R8), R4
MOVW R4, 12(R13)
MOVW syscall15Args_a9(R8), R4
MOVW R4, 16(R13)
MOVW syscall15Args_a10(R8), R4
MOVW R4, 20(R13)
MOVW syscall15Args_a11(R8), R4
MOVW R4, 24(R13)
MOVW syscall15Args_a12(R8), R4
MOVW R4, 28(R13)
MOVW syscall15Args_a13(R8), R4
MOVW R4, 32(R13)
MOVW syscall15Args_a14(R8), R4
MOVW R4, 36(R13)
MOVW syscall15Args_a15(R8), R4
MOVW R4, 40(R13)
MOVW syscall15Args_a16(R8), R4
MOVW R4, 44(R13)
MOVW syscall15Args_a17(R8), R4
MOVW R4, 48(R13)
MOVW syscall15Args_a18(R8), R4
MOVW R4, 52(R13)
MOVW syscall15Args_a19(R8), R4
MOVW R4, 56(R13)
MOVW syscall15Args_a20(R8), R4
MOVW R4, 60(R13)
MOVW syscall15Args_a21(R8), R4
MOVW R4, 64(R13)
MOVW syscall15Args_a22(R8), R4
MOVW R4, 68(R13)
MOVW syscall15Args_a23(R8), R4
MOVW R4, 72(R13)
MOVW syscall15Args_a24(R8), R4
MOVW R4, 76(R13)
MOVW syscall15Args_a25(R8), R4
MOVW R4, 80(R13)
MOVW syscall15Args_a26(R8), R4
MOVW R4, 84(R13)
MOVW syscall15Args_a27(R8), R4
MOVW R4, 88(R13)
MOVW syscall15Args_a28(R8), R4
MOVW R4, 92(R13)
MOVW syscall15Args_a29(R8), R4
MOVW R4, 96(R13)
MOVW syscall15Args_a30(R8), R4
MOVW R4, 100(R13)
MOVW syscall15Args_a31(R8), R4
MOVW R4, 104(R13)
MOVW syscall15Args_a32(R8), R4
MOVW R4, 108(R13)
// Load saved function pointer and call
MOVW (PTR_ADDRESS-4)(R13), R4
// Use BLX for Thumb interworking - Go assembler doesn't support BLX Rn
// BLX R4 = 0xE12FFF34 (ARM encoding, always condition)
WORD $0xE12FFF34 // blx r4
// pop structure pointer
MOVW PTR_ADDRESS(R13), R8
ADD $STACK_SIZE, R13
// save R0, R1
MOVW R0, syscall15Args_a1(R8)
MOVW R1, syscall15Args_a2(R8)
// save f0-f3 (each float64 spans 2 uintptr slots on ARM32)
MOVD F0, syscall15Args_f1(R8)
MOVD F1, syscall15Args_f3(R8)
MOVD F2, syscall15Args_f5(R8)
MOVD F3, syscall15Args_f7(R8)
// Restore callee-saved registers and return
MOVM.IA.W (R13), [R4, R5, R6, R7, R8, R9, R11]
MOVW.P 4(R13), R15 // pop LR into PC (return)
golang-github-ebitengine-purego-0.10.1/sys_arm64.s 0000664 0000000 0000000 00000005467 15207302613 0021754 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd || windows
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#define STACK_SIZE 64
#define PTR_ADDRESS (STACK_SIZE - 8)
// syscall15X calls a function in libc on behalf of the syscall package.
// syscall15X takes a pointer to a struct like:
// struct {
// fn uintptr
// a1 uintptr
// a2 uintptr
// a3 uintptr
// a4 uintptr
// a5 uintptr
// a6 uintptr
// a7 uintptr
// a8 uintptr
// a9 uintptr
// a10 uintptr
// a11 uintptr
// a12 uintptr
// a13 uintptr
// a14 uintptr
// a15 uintptr
// r1 uintptr
// r2 uintptr
// err uintptr
// }
// syscall15X must be called on the g0 stack with the
// C calling convention (use libcCall).
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT, $0
SUB $STACK_SIZE, RSP // push structure pointer
MOVD R0, PTR_ADDRESS(RSP)
MOVD R0, R9
FMOVD syscall15Args_f1(R9), F0 // f1
FMOVD syscall15Args_f2(R9), F1 // f2
FMOVD syscall15Args_f3(R9), F2 // f3
FMOVD syscall15Args_f4(R9), F3 // f4
FMOVD syscall15Args_f5(R9), F4 // f5
FMOVD syscall15Args_f6(R9), F5 // f6
FMOVD syscall15Args_f7(R9), F6 // f7
FMOVD syscall15Args_f8(R9), F7 // f8
MOVD syscall15Args_a1(R9), R0 // a1
MOVD syscall15Args_a2(R9), R1 // a2
MOVD syscall15Args_a3(R9), R2 // a3
MOVD syscall15Args_a4(R9), R3 // a4
MOVD syscall15Args_a5(R9), R4 // a5
MOVD syscall15Args_a6(R9), R5 // a6
MOVD syscall15Args_a7(R9), R6 // a7
MOVD syscall15Args_a8(R9), R7 // a8
MOVD syscall15Args_arm64_r8(R9), R8 // r8
MOVD syscall15Args_a9(R9), R10
MOVD R10, 0(RSP) // push a9 onto stack
MOVD syscall15Args_a10(R9), R10
MOVD R10, 8(RSP) // push a10 onto stack
MOVD syscall15Args_a11(R9), R10
MOVD R10, 16(RSP) // push a11 onto stack
MOVD syscall15Args_a12(R9), R10
MOVD R10, 24(RSP) // push a12 onto stack
MOVD syscall15Args_a13(R9), R10
MOVD R10, 32(RSP) // push a13 onto stack
MOVD syscall15Args_a14(R9), R10
MOVD R10, 40(RSP) // push a14 onto stack
MOVD syscall15Args_a15(R9), R10
MOVD R10, 48(RSP) // push a15 onto stack
MOVD syscall15Args_fn(R9), R10 // fn
BL (R10)
MOVD PTR_ADDRESS(RSP), R2 // pop structure pointer
ADD $STACK_SIZE, RSP
MOVD R0, syscall15Args_a1(R2) // save r1
MOVD R1, syscall15Args_a2(R2) // save r3
FMOVD F0, syscall15Args_f1(R2) // save f0
FMOVD F1, syscall15Args_f2(R2) // save f1
FMOVD F2, syscall15Args_f3(R2) // save f2
FMOVD F3, syscall15Args_f4(R2) // save f3
#ifdef GOOS_darwin
BL purego_error(SB)
MOVD (R0), R0
MOVD R0, syscall15Args_a3(R2) // save errno
#endif
RET
golang-github-ebitengine-purego-0.10.1/sys_loong64.s 0000664 0000000 0000000 00000004502 15207302613 0022300 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#define STACK_SIZE 64
#define PTR_ADDRESS (STACK_SIZE - 8)
// syscall15X calls a function in libc on behalf of the syscall package.
// syscall15X takes a pointer to a struct like:
// struct {
// fn uintptr
// a1 uintptr
// a2 uintptr
// a3 uintptr
// a4 uintptr
// a5 uintptr
// a6 uintptr
// a7 uintptr
// a8 uintptr
// a9 uintptr
// a10 uintptr
// a11 uintptr
// a12 uintptr
// a13 uintptr
// a14 uintptr
// a15 uintptr
// r1 uintptr
// r2 uintptr
// err uintptr
// }
// syscall15X must be called on the g0 stack with the
// C calling convention (use libcCall).
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT, $0
// push structure pointer
SUBV $STACK_SIZE, R3
MOVV R4, PTR_ADDRESS(R3)
MOVV R4, R13
MOVD syscall15Args_f1(R13), F0 // f1
MOVD syscall15Args_f2(R13), F1 // f2
MOVD syscall15Args_f3(R13), F2 // f3
MOVD syscall15Args_f4(R13), F3 // f4
MOVD syscall15Args_f5(R13), F4 // f5
MOVD syscall15Args_f6(R13), F5 // f6
MOVD syscall15Args_f7(R13), F6 // f7
MOVD syscall15Args_f8(R13), F7 // f8
MOVV syscall15Args_a1(R13), R4 // a1
MOVV syscall15Args_a2(R13), R5 // a2
MOVV syscall15Args_a3(R13), R6 // a3
MOVV syscall15Args_a4(R13), R7 // a4
MOVV syscall15Args_a5(R13), R8 // a5
MOVV syscall15Args_a6(R13), R9 // a6
MOVV syscall15Args_a7(R13), R10 // a7
MOVV syscall15Args_a8(R13), R11 // a8
// push a9-a15 onto stack
MOVV syscall15Args_a9(R13), R12
MOVV R12, 0(R3)
MOVV syscall15Args_a10(R13), R12
MOVV R12, 8(R3)
MOVV syscall15Args_a11(R13), R12
MOVV R12, 16(R3)
MOVV syscall15Args_a12(R13), R12
MOVV R12, 24(R3)
MOVV syscall15Args_a13(R13), R12
MOVV R12, 32(R3)
MOVV syscall15Args_a14(R13), R12
MOVV R12, 40(R3)
MOVV syscall15Args_a15(R13), R12
MOVV R12, 48(R3)
MOVV syscall15Args_fn(R13), R12
JAL (R12)
// pop structure pointer
MOVV PTR_ADDRESS(R3), R13
ADDV $STACK_SIZE, R3
// save R4, R5
MOVV R4, syscall15Args_a1(R13)
MOVV R5, syscall15Args_a2(R13)
// save f0-f3
MOVD F0, syscall15Args_f1(R13)
MOVD F1, syscall15Args_f2(R13)
MOVD F2, syscall15Args_f3(R13)
MOVD F3, syscall15Args_f4(R13)
RET
golang-github-ebitengine-purego-0.10.1/sys_ppc64le.s 0000664 0000000 0000000 00000007056 15207302613 0022274 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// PPC64LE ELFv2 ABI:
// - Integer args: R3-R10 (8 registers)
// - Float args: F1-F8 (8 registers)
// - Return: R3 (integer), F1 (float)
// - Stack pointer: R1
// - Link register: LR (special)
// - TOC pointer: R2 (must preserve)
// Stack layout for ELFv2 ABI (aligned to 16 bytes):
// From callee's perspective when we call BL (CTR):
// 0(R1) - back chain (our old R1)
// 8(R1) - CR save word (optional)
// 16(R1) - LR save (optional, we save it)
// 24(R1) - Reserved (compilers)
// 32(R1) - Parameter save area start (8 * 8 = 64 bytes for R3-R10)
// 96(R1) - First stack arg (a9) - this is where callee looks
// 104(R1) - Second stack arg (a10)
// 112-152 - Stack args a11-a15 (5 * 8 = 40 bytes)
// 160(R1) - TOC save (we put it here, outside param save area)
// 168(R1) - saved args pointer
// 176(R1) - padding for 16-byte alignment
// Total: 176 bytes
#define STACK_SIZE 176
#define LR_SAVE 16
#define TOC_SAVE 160
#define ARGP_SAVE 168
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT, $0
// Prologue: create stack frame
// R3 contains the args pointer on entry
MOVD R1, R12 // save old SP
SUB $STACK_SIZE, R1 // allocate stack frame
MOVD R12, 0(R1) // save back chain
MOVD LR, R12
MOVD R12, LR_SAVE(R1) // save LR
MOVD R2, TOC_SAVE(R1) // save TOC
// Save args pointer (in R3)
MOVD R3, ARGP_SAVE(R1)
// R11 := args pointer (syscall15Args*)
MOVD R3, R11
// Load float args into F1-F8
FMOVD syscall15Args_f1(R11), F1
FMOVD syscall15Args_f2(R11), F2
FMOVD syscall15Args_f3(R11), F3
FMOVD syscall15Args_f4(R11), F4
FMOVD syscall15Args_f5(R11), F5
FMOVD syscall15Args_f6(R11), F6
FMOVD syscall15Args_f7(R11), F7
FMOVD syscall15Args_f8(R11), F8
// Load integer args into R3-R10
MOVD syscall15Args_a1(R11), R3
MOVD syscall15Args_a2(R11), R4
MOVD syscall15Args_a3(R11), R5
MOVD syscall15Args_a4(R11), R6
MOVD syscall15Args_a5(R11), R7
MOVD syscall15Args_a6(R11), R8
MOVD syscall15Args_a7(R11), R9
MOVD syscall15Args_a8(R11), R10
// Spill a9-a15 onto the stack (stack parameters start at 96(R1))
// Per ELFv2: parameter save area is 32-95, stack args start at 96
MOVD ARGP_SAVE(R1), R11 // reload args pointer
MOVD syscall15Args_a9(R11), R12
MOVD R12, 96(R1) // a9 at 96(R1)
MOVD syscall15Args_a10(R11), R12
MOVD R12, 104(R1) // a10 at 104(R1)
MOVD syscall15Args_a11(R11), R12
MOVD R12, 112(R1) // a11 at 112(R1)
MOVD syscall15Args_a12(R11), R12
MOVD R12, 120(R1) // a12 at 120(R1)
MOVD syscall15Args_a13(R11), R12
MOVD R12, 128(R1) // a13 at 128(R1)
MOVD syscall15Args_a14(R11), R12
MOVD R12, 136(R1) // a14 at 136(R1)
MOVD syscall15Args_a15(R11), R12
MOVD R12, 144(R1) // a15 at 144(R1)
// Call function: load fn and call
MOVD syscall15Args_fn(R11), R12
MOVD R12, CTR
BL (CTR)
// Restore TOC after call
MOVD TOC_SAVE(R1), R2
// Restore args pointer for storing results
MOVD ARGP_SAVE(R1), R11
// Store integer results back (R3, R4)
MOVD R3, syscall15Args_a1(R11)
MOVD R4, syscall15Args_a2(R11)
// Store float return values (F1-F4)
FMOVD F1, syscall15Args_f1(R11)
FMOVD F2, syscall15Args_f2(R11)
FMOVD F3, syscall15Args_f3(R11)
FMOVD F4, syscall15Args_f4(R11)
// Epilogue: restore and return
MOVD LR_SAVE(R1), R12
MOVD R12, LR
ADD $STACK_SIZE, R1
RET
golang-github-ebitengine-purego-0.10.1/sys_riscv64.s 0000664 0000000 0000000 00000005043 15207302613 0022311 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// Stack usage:
// 0(SP) - 56(SP): stack args a9-a15 (7 * 8 bytes = 56)
// 56(SP) - 64(SP): saved RA (x1)
// 64(SP) - 72(SP): saved X9 (s1)
// 72(SP) - 80(SP): saved X18 (s2)
// 80(SP) - 88(SP): saved args pointer (original X10)
// 88(SP) - 96(SP): padding
#define STACK_SIZE 96
#define SAVE_RA 56
#define SAVE_X9 64
#define SAVE_X18 72
#define SAVE_ARGP 80
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT, $0
// Allocate stack frame (keeps 16-byte alignment)
SUB $STACK_SIZE, SP
// Save callee-saved regs we clobber + return address
MOV X1, SAVE_RA(SP)
MOV X9, SAVE_X9(SP)
MOV X18, SAVE_X18(SP)
// Save original args pointer (in a0/X10)
MOV X10, SAVE_ARGP(SP)
// X9 := args pointer (syscall15Args*)
MOV X10, X9
// Load float args into fa0-fa7 (F10-F17)
MOVD syscall15Args_f1(X9), F10
MOVD syscall15Args_f2(X9), F11
MOVD syscall15Args_f3(X9), F12
MOVD syscall15Args_f4(X9), F13
MOVD syscall15Args_f5(X9), F14
MOVD syscall15Args_f6(X9), F15
MOVD syscall15Args_f7(X9), F16
MOVD syscall15Args_f8(X9), F17
// Load integer args into a0-a7 (X10-X17)
MOV syscall15Args_a1(X9), X10
MOV syscall15Args_a2(X9), X11
MOV syscall15Args_a3(X9), X12
MOV syscall15Args_a4(X9), X13
MOV syscall15Args_a5(X9), X14
MOV syscall15Args_a6(X9), X15
MOV syscall15Args_a7(X9), X16
MOV syscall15Args_a8(X9), X17
// Spill a9-a15 onto the stack (C ABI)
MOV syscall15Args_a9(X9), X18
MOV X18, 0(SP)
MOV syscall15Args_a10(X9), X18
MOV X18, 8(SP)
MOV syscall15Args_a11(X9), X18
MOV X18, 16(SP)
MOV syscall15Args_a12(X9), X18
MOV X18, 24(SP)
MOV syscall15Args_a13(X9), X18
MOV X18, 32(SP)
MOV syscall15Args_a14(X9), X18
MOV X18, 40(SP)
MOV syscall15Args_a15(X9), X18
MOV X18, 48(SP)
// Call fn
// IMPORTANT: preserve RA across this call (we saved it above)
MOV syscall15Args_fn(X9), X18
CALL X18
// Restore args pointer (syscall15Args*) for storing results
MOV SAVE_ARGP(SP), X9
// Store results back
MOV X10, syscall15Args_a1(X9)
MOV X11, syscall15Args_a2(X9)
// Store back float return regs if used by your ABI contract
MOVD F10, syscall15Args_f1(X9)
MOVD F11, syscall15Args_f2(X9)
MOVD F12, syscall15Args_f3(X9)
MOVD F13, syscall15Args_f4(X9)
// Restore callee-saved regs and return address
MOV SAVE_X18(SP), X18
MOV SAVE_X9(SP), X9
MOV SAVE_RA(SP), X1
ADD $STACK_SIZE, SP
RET
golang-github-ebitengine-purego-0.10.1/sys_s390x.s 0000664 0000000 0000000 00000006127 15207302613 0021703 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// S390X ELF ABI:
// - Integer args: R2-R6 (5 registers)
// - Float args: F0, F2, F4, F6 (4 registers, even-numbered)
// - Return: R2 (integer), F0 (float)
// - Stack pointer: R15
// - Link register: R14
// - Callee-saved: R6-R13, F8-F15 (but R6 is also used for 5th param)
//
// Stack frame layout (aligned to 8 bytes):
// 0(R15) - back chain
// 8(R15) - reserved
// 16(R15) - reserved
// ... - register save area (R6-R15 at 48(R15))
// 160(R15) - parameter area start (args beyond registers)
//
// We need space for:
// - 160 bytes standard frame (with register save area)
// - Stack args a6-a15 (10 * 8 = 80 bytes)
// - Saved args pointer (8 bytes)
// - Padding for alignment
// Total: 264 bytes (rounded to 8-byte alignment)
#define STACK_SIZE 264
#define STACK_ARGS 160
#define ARGP_SAVE 248
GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
TEXT syscall15X(SB), NOSPLIT, $0
// On entry, R2 contains the args pointer
// Save callee-saved registers in caller's frame (per ABI)
STMG R6, R15, 48(R15)
// Allocate our stack frame
MOVD R15, R1
SUB $STACK_SIZE, R15
MOVD R1, 0(R15) // back chain
// Save args pointer
MOVD R2, ARGP_SAVE(R15)
// R9 := args pointer (syscall15Args*)
MOVD R2, R9
// Load float args into F0, F2, F4, F6 (s390x uses even-numbered FPRs)
FMOVD syscall15Args_f1(R9), F0
FMOVD syscall15Args_f2(R9), F2
FMOVD syscall15Args_f3(R9), F4
FMOVD syscall15Args_f4(R9), F6
// Load integer args into R2-R6 (5 registers)
MOVD syscall15Args_a1(R9), R2
MOVD syscall15Args_a2(R9), R3
MOVD syscall15Args_a3(R9), R4
MOVD syscall15Args_a4(R9), R5
MOVD syscall15Args_a5(R9), R6
// Spill remaining args (a6-a15) onto the stack at 160(R15)
MOVD ARGP_SAVE(R15), R9 // reload args pointer
MOVD syscall15Args_a6(R9), R1
MOVD R1, (STACK_ARGS+0*8)(R15)
MOVD syscall15Args_a7(R9), R1
MOVD R1, (STACK_ARGS+1*8)(R15)
MOVD syscall15Args_a8(R9), R1
MOVD R1, (STACK_ARGS+2*8)(R15)
MOVD syscall15Args_a9(R9), R1
MOVD R1, (STACK_ARGS+3*8)(R15)
MOVD syscall15Args_a10(R9), R1
MOVD R1, (STACK_ARGS+4*8)(R15)
MOVD syscall15Args_a11(R9), R1
MOVD R1, (STACK_ARGS+5*8)(R15)
MOVD syscall15Args_a12(R9), R1
MOVD R1, (STACK_ARGS+6*8)(R15)
MOVD syscall15Args_a13(R9), R1
MOVD R1, (STACK_ARGS+7*8)(R15)
MOVD syscall15Args_a14(R9), R1
MOVD R1, (STACK_ARGS+8*8)(R15)
MOVD syscall15Args_a15(R9), R1
MOVD R1, (STACK_ARGS+9*8)(R15)
// Call function
MOVD syscall15Args_fn(R9), R1
BL (R1)
// Restore args pointer for storing results
MOVD ARGP_SAVE(R15), R9
// Store integer results back (R2, R3)
MOVD R2, syscall15Args_a1(R9)
MOVD R3, syscall15Args_a2(R9)
// Store float return values (F0, F2, F4, F6)
FMOVD F0, syscall15Args_f1(R9)
FMOVD F2, syscall15Args_f2(R9)
FMOVD F4, syscall15Args_f3(R9)
FMOVD F6, syscall15Args_f4(R9)
// Deallocate stack frame
ADD $STACK_SIZE, R15
// Restore callee-saved registers from caller's save area
LMG 48(R15), R6, R15
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_386.s 0000664 0000000 0000000 00000012036 15207302613 0022374 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// callbackasm1 is the second part of the callback trampoline.
// On entry:
// - CX contains the callback index (set by callbackasm)
// - 0(SP) contains the return address to C caller
// - 4(SP), 8(SP), ... contain C arguments (cdecl convention)
//
// i386 cdecl calling convention:
// - All arguments passed on stack
// - Return value in EAX (and EDX for 64-bit)
// - Caller cleans the stack
// - Callee must preserve: EBX, ESI, EDI, EBP
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
// Save the return address
MOVL 0(SP), AX
// Allocate stack frame (must be done carefully to preserve args access)
// Layout:
// 0-15: saved callee-saved registers (BX, SI, DI, BP)
// 16-19: saved callback index
// 20-23: saved return address
// 24-35: callbackArgs struct (12 bytes)
// 36-291: copy of C arguments (256 bytes for 64 args, matching callbackMaxFrame)
// Total: 292 bytes, round up to 304 for alignment
SUBL $304, SP
// Save callee-saved registers
MOVL BX, 0(SP)
MOVL SI, 4(SP)
MOVL DI, 8(SP)
MOVL BP, 12(SP)
// Save callback index and return address
MOVL CX, 16(SP)
MOVL AX, 20(SP)
// Copy C arguments from original stack location to our frame
// Original args start at 304+4(SP) = 308(SP) (past our frame + original return addr)
// Copy to our frame at 36(SP)
// Copy 64 arguments (256 bytes, matching callbackMaxFrame = 64 * ptrSize)
MOVL 308(SP), AX
MOVL AX, 36(SP)
MOVL 312(SP), AX
MOVL AX, 40(SP)
MOVL 316(SP), AX
MOVL AX, 44(SP)
MOVL 320(SP), AX
MOVL AX, 48(SP)
MOVL 324(SP), AX
MOVL AX, 52(SP)
MOVL 328(SP), AX
MOVL AX, 56(SP)
MOVL 332(SP), AX
MOVL AX, 60(SP)
MOVL 336(SP), AX
MOVL AX, 64(SP)
MOVL 340(SP), AX
MOVL AX, 68(SP)
MOVL 344(SP), AX
MOVL AX, 72(SP)
MOVL 348(SP), AX
MOVL AX, 76(SP)
MOVL 352(SP), AX
MOVL AX, 80(SP)
MOVL 356(SP), AX
MOVL AX, 84(SP)
MOVL 360(SP), AX
MOVL AX, 88(SP)
MOVL 364(SP), AX
MOVL AX, 92(SP)
MOVL 368(SP), AX
MOVL AX, 96(SP)
MOVL 372(SP), AX
MOVL AX, 100(SP)
MOVL 376(SP), AX
MOVL AX, 104(SP)
MOVL 380(SP), AX
MOVL AX, 108(SP)
MOVL 384(SP), AX
MOVL AX, 112(SP)
MOVL 388(SP), AX
MOVL AX, 116(SP)
MOVL 392(SP), AX
MOVL AX, 120(SP)
MOVL 396(SP), AX
MOVL AX, 124(SP)
MOVL 400(SP), AX
MOVL AX, 128(SP)
MOVL 404(SP), AX
MOVL AX, 132(SP)
MOVL 408(SP), AX
MOVL AX, 136(SP)
MOVL 412(SP), AX
MOVL AX, 140(SP)
MOVL 416(SP), AX
MOVL AX, 144(SP)
MOVL 420(SP), AX
MOVL AX, 148(SP)
MOVL 424(SP), AX
MOVL AX, 152(SP)
MOVL 428(SP), AX
MOVL AX, 156(SP)
MOVL 432(SP), AX
MOVL AX, 160(SP)
MOVL 436(SP), AX
MOVL AX, 164(SP)
MOVL 440(SP), AX
MOVL AX, 168(SP)
MOVL 444(SP), AX
MOVL AX, 172(SP)
MOVL 448(SP), AX
MOVL AX, 176(SP)
MOVL 452(SP), AX
MOVL AX, 180(SP)
MOVL 456(SP), AX
MOVL AX, 184(SP)
MOVL 460(SP), AX
MOVL AX, 188(SP)
MOVL 464(SP), AX
MOVL AX, 192(SP)
MOVL 468(SP), AX
MOVL AX, 196(SP)
MOVL 472(SP), AX
MOVL AX, 200(SP)
MOVL 476(SP), AX
MOVL AX, 204(SP)
MOVL 480(SP), AX
MOVL AX, 208(SP)
MOVL 484(SP), AX
MOVL AX, 212(SP)
MOVL 488(SP), AX
MOVL AX, 216(SP)
MOVL 492(SP), AX
MOVL AX, 220(SP)
MOVL 496(SP), AX
MOVL AX, 224(SP)
MOVL 500(SP), AX
MOVL AX, 228(SP)
MOVL 504(SP), AX
MOVL AX, 232(SP)
MOVL 508(SP), AX
MOVL AX, 236(SP)
MOVL 512(SP), AX
MOVL AX, 240(SP)
MOVL 516(SP), AX
MOVL AX, 244(SP)
MOVL 520(SP), AX
MOVL AX, 248(SP)
MOVL 524(SP), AX
MOVL AX, 252(SP)
MOVL 528(SP), AX
MOVL AX, 256(SP)
MOVL 532(SP), AX
MOVL AX, 260(SP)
MOVL 536(SP), AX
MOVL AX, 264(SP)
MOVL 540(SP), AX
MOVL AX, 268(SP)
MOVL 544(SP), AX
MOVL AX, 272(SP)
MOVL 548(SP), AX
MOVL AX, 276(SP)
MOVL 552(SP), AX
MOVL AX, 280(SP)
MOVL 556(SP), AX
MOVL AX, 284(SP)
MOVL 560(SP), AX
MOVL AX, 288(SP)
// Set up callbackArgs struct at 24(SP)
// struct callbackArgs {
// index uintptr // offset 0
// args *byte // offset 4
// result uintptr // offset 8
// }
MOVL 16(SP), AX // callback index
MOVL AX, 24(SP) // callbackArgs.index
LEAL 36(SP), AX // pointer to copied arguments
MOVL AX, 28(SP) // callbackArgs.args
MOVL $0, 32(SP) // callbackArgs.result = 0
// Call crosscall2(fn, frame, 0, ctxt)
// crosscall2 expects arguments on stack:
// 0(SP) = fn
// 4(SP) = frame (pointer to callbackArgs)
// 8(SP) = ignored (was n)
// 12(SP) = ctxt
SUBL $16, SP
MOVL ·callbackWrap_call(SB), AX
MOVL (AX), AX // fn = *callbackWrap_call
MOVL AX, 0(SP) // fn
LEAL (24+16)(SP), AX // &callbackArgs (adjusted for SUB $16)
MOVL AX, 4(SP) // frame
MOVL $0, 8(SP) // 0
MOVL $0, 12(SP) // ctxt
CALL crosscall2(SB)
ADDL $16, SP
// Get result from callbackArgs.result
MOVL 32(SP), AX
// Restore callee-saved registers
MOVL 0(SP), BX
MOVL 4(SP), SI
MOVL 8(SP), DI
MOVL 12(SP), BP
// Restore return address and clean up
MOVL 20(SP), CX // get return address
ADDL $304, SP // remove our frame
MOVL CX, 0(SP) // put return address back
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_arm.s 0000664 0000000 0000000 00000003261 15207302613 0022633 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
// Allocate stack frame: 48 + 16 + 64 + 16 = 144 bytes
SUB $144, R13
// Save callee-saved registers at SP+0
MOVW R4, 0(R13)
MOVW R5, 4(R13)
MOVW R6, 8(R13)
MOVW R7, 12(R13)
MOVW R8, 16(R13)
MOVW R9, 20(R13)
MOVW g, 24(R13)
MOVW R11, 28(R13)
MOVW R14, 32(R13)
// Save callback index (passed in R12) at SP+36
MOVW R12, 36(R13)
// Save integer arguments R0-R3 at SP+128 (frame[16..19])
MOVW R0, 128(R13)
MOVW R1, 132(R13)
MOVW R2, 136(R13)
MOVW R3, 140(R13)
// Save floating point registers F0-F7 at SP+64 (frame[0..15])
// Note: We always save these since we target hard-float ABI.
MOVD F0, 64(R13)
MOVD F1, 72(R13)
MOVD F2, 80(R13)
MOVD F3, 88(R13)
MOVD F4, 96(R13)
MOVD F5, 104(R13)
MOVD F6, 112(R13)
MOVD F7, 120(R13)
// Set up callbackArgs at SP+48
MOVW 36(R13), R4
MOVW R4, 48(R13)
ADD $64, R13, R4
MOVW R4, 52(R13)
MOVW $0, R4
MOVW R4, 56(R13)
// Call crosscall2(fn, frame, 0, ctxt)
MOVW ·callbackWrap_call(SB), R0
MOVW (R0), R0
ADD $48, R13, R1
MOVW $0, R2
MOVW $0, R3
BL crosscall2(SB)
// Get result
MOVW 56(R13), R0
// Restore float registers
MOVD 64(R13), F0
MOVD 72(R13), F1
MOVD 80(R13), F2
MOVD 88(R13), F3
MOVD 96(R13), F4
MOVD 104(R13), F5
MOVD 112(R13), F6
MOVD 120(R13), F7
// Restore callee-saved registers
MOVW 0(R13), R4
MOVW 4(R13), R5
MOVW 8(R13), R6
MOVW 12(R13), R7
MOVW 16(R13), R8
MOVW 20(R13), R9
MOVW 24(R13), g
MOVW 28(R13), R11
MOVW 32(R13), R14
ADD $144, R13
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_arm64.s 0000664 0000000 0000000 00000004116 15207302613 0023005 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
//go:build darwin || freebsd || linux || netbsd
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#include "abi_arm64.h"
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
// On entry, the trampoline in zcallback_darwin_arm64.s left
// the callback index in R12 (which is volatile in the C ABI).
// Save callback register arguments R0-R7 and F0-F7.
// We do this at the top of the frame so they're contiguous with stack arguments.
SUB $(16*8), RSP, R14
FSTPD (F0, F1), (0*8)(R14)
FSTPD (F2, F3), (2*8)(R14)
FSTPD (F4, F5), (4*8)(R14)
FSTPD (F6, F7), (6*8)(R14)
STP (R0, R1), (8*8)(R14)
STP (R2, R3), (10*8)(R14)
STP (R4, R5), (12*8)(R14)
STP (R6, R7), (14*8)(R14)
// Adjust SP by frame size.
SUB $(26*8), RSP
// It is important to save R27 because the go assembler
// uses it for move instructions for a variable.
// This line:
// MOVD ·callbackWrap_call(SB), R0
// Creates the instructions:
// ADRP 14335(PC), R27
// MOVD 388(27), R0
// R27 is a callee saved register so we are responsible
// for ensuring its value doesn't change. So save it and
// restore it at the end of this function.
// R30 is the link register. crosscall2 doesn't save it
// so it's saved here.
STP (R27, R30), 0(RSP)
// Create a struct callbackArgs on our stack.
MOVD $(callbackArgs__size)(RSP), R13
MOVD R12, callbackArgs_index(R13) // callback index
MOVD R14, callbackArgs_args(R13) // address of args vector
MOVD ZR, callbackArgs_result(R13) // result
// Move parameters into registers
// Get the ABIInternal function pointer
// without by using a closure.
MOVD ·callbackWrap_call(SB), R0
MOVD (R0), R0 // fn unsafe.Pointer
MOVD R13, R1 // frame (&callbackArgs{...})
MOVD $0, R3 // ctxt uintptr
BL crosscall2(SB)
// Get callback result.
MOVD $(callbackArgs__size)(RSP), R13
MOVD callbackArgs_result(R13), R0
// Restore LR and R27
LDP 0(RSP), (R27, R30)
ADD $(26*8), RSP
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_loong64.s 0000664 0000000 0000000 00000003573 15207302613 0023352 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
#include "abi_loong64.h"
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
SUBV $(16*8), R3, R14
MOVD F0, 0(R14)
MOVD F1, 8(R14)
MOVD F2, 16(R14)
MOVD F3, 24(R14)
MOVD F4, 32(R14)
MOVD F5, 40(R14)
MOVD F6, 48(R14)
MOVD F7, 56(R14)
MOVV R4, 64(R14)
MOVV R5, 72(R14)
MOVV R6, 80(R14)
MOVV R7, 88(R14)
MOVV R8, 96(R14)
MOVV R9, 104(R14)
MOVV R10, 112(R14)
MOVV R11, 120(R14)
// Adjust SP by frame size.
SUBV $(22*8), R3
// It is important to save R30 because the go assembler
// uses it for move instructions for a variable.
// This line:
// MOVV ·callbackWrap_call(SB), R4
// Creates the instructions:
// PCALAU12I off1(PC), R30
// MOVV off2(R30), R4
// R30 is a callee saved register so we are responsible
// for ensuring its value doesn't change. So save it and
// restore it at the end of this function.
// R1 is the link register. crosscall2 doesn't save it
// so it's saved here.
MOVV R1, 0(R3)
MOVV R30, 8(R3)
// Create a struct callbackArgs on our stack.
MOVV $(callbackArgs__size)(R3), R13
MOVV R12, callbackArgs_index(R13) // callback index
MOVV R14, callbackArgs_args(R13) // address of args vector
MOVV $0, callbackArgs_result(R13) // result
// Move parameters into registers
// Get the ABIInternal function pointer
// without by using a closure.
MOVV ·callbackWrap_call(SB), R4
MOVV (R4), R4 // fn unsafe.Pointer
MOVV R13, R5 // frame (&callbackArgs{...})
MOVV $0, R7 // ctxt uintptr
JAL crosscall2(SB)
// Get callback result.
MOVV $(callbackArgs__size)(R3), R13
MOVV callbackArgs_result(R13), R4
// Restore LR and R30
MOVV 0(R3), R1
MOVV 8(R3), R30
ADDV $(22*8), R3
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_ppc64le.s 0000664 0000000 0000000 00000007501 15207302613 0023332 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// PPC64LE ELFv2 ABI callbackasm1 implementation
// On entry, R11 contains the callback index (set by callbackasm)
//
// ELFv2 stack frame layout requirements:
// 0(R1) - back chain (pointer to caller's frame)
// 8(R1) - CR save area (optional)
// 16(R1) - LR save area (for callee to save caller's LR)
// 24(R1) - TOC save area (if needed)
// 32(R1)+ - parameter save area / local variables
//
// Our frame (total 208 bytes, 16-byte aligned):
// 32(R1) - saved R31 (8 bytes)
// 40(R1) - callbackArgs struct (32 bytes: index, args, result, stackArgs)
// 72(R1) - args array: floats (64) + ints (64) = 128 bytes, ends at 200
// Total with alignment: 208 bytes
//
// Stack args are NOT copied - we pass a pointer to their location in caller's frame.
// This keeps frame size small enough for NOSPLIT with CGO_ENABLED=1.
// Budget: 208 + 544 (crosscall2) + 56 (cgocallback) = 808 bytes
// This is 8 bytes over the 800 limit, but cgocallback's children (load_g, save_g)
// reuse the same stack space, so in practice it works.
#define FRAME_SIZE 200
#define SAVE_R31 32
#define CB_ARGS 40
#define ARGS_ARRAY 72
#define FLOAT_OFF 0
#define INT_OFF 64
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
// On entry, the trampoline in zcallback_ppc64le.s left
// the callback index in R11.
// Per ELFv2 ABI, save LR to caller's frame BEFORE allocating our frame
MOVD LR, R0
MOVD R0, 16(R1)
// Allocate our stack frame (with back chain via MOVDU)
MOVDU R1, -FRAME_SIZE(R1)
// Save R31 - Go assembler uses it for MOVD from SB (like arm64's R27)
MOVD R31, SAVE_R31(R1)
// Save R11 (callback index) immediately - it's volatile and will be clobbered!
// Store it in the callbackArgs struct's index field now.
MOVD R11, (CB_ARGS+0)(R1)
// Save callback arguments to args array.
// Layout: floats first (F1-F8), then ints (R3-R10), then stack args
FMOVD F1, (ARGS_ARRAY+FLOAT_OFF+0*8)(R1)
FMOVD F2, (ARGS_ARRAY+FLOAT_OFF+1*8)(R1)
FMOVD F3, (ARGS_ARRAY+FLOAT_OFF+2*8)(R1)
FMOVD F4, (ARGS_ARRAY+FLOAT_OFF+3*8)(R1)
FMOVD F5, (ARGS_ARRAY+FLOAT_OFF+4*8)(R1)
FMOVD F6, (ARGS_ARRAY+FLOAT_OFF+5*8)(R1)
FMOVD F7, (ARGS_ARRAY+FLOAT_OFF+6*8)(R1)
FMOVD F8, (ARGS_ARRAY+FLOAT_OFF+7*8)(R1)
MOVD R3, (ARGS_ARRAY+INT_OFF+0*8)(R1)
MOVD R4, (ARGS_ARRAY+INT_OFF+1*8)(R1)
MOVD R5, (ARGS_ARRAY+INT_OFF+2*8)(R1)
MOVD R6, (ARGS_ARRAY+INT_OFF+3*8)(R1)
MOVD R7, (ARGS_ARRAY+INT_OFF+4*8)(R1)
MOVD R8, (ARGS_ARRAY+INT_OFF+5*8)(R1)
MOVD R9, (ARGS_ARRAY+INT_OFF+6*8)(R1)
MOVD R10, (ARGS_ARRAY+INT_OFF+7*8)(R1)
// Finish setting up callbackArgs struct at CB_ARGS(R1)
// struct { index uintptr; args unsafe.Pointer; result uintptr; stackArgs unsafe.Pointer }
// Note: index was already saved earlier (R11 is volatile)
ADD $ARGS_ARRAY, R1, R12
MOVD R12, (CB_ARGS+8)(R1) // args = address of register args
MOVD $0, (CB_ARGS+16)(R1) // result = 0
// stackArgs points to caller's stack arguments at old_R1+96 = R1+FRAME_SIZE+96
ADD $(FRAME_SIZE+96), R1, R12
MOVD R12, (CB_ARGS+24)(R1) // stackArgs = &caller_stack_args
// Call crosscall2 with arguments in registers:
// R3 = fn (from callbackWrap_call closure)
// R4 = frame (address of callbackArgs)
// R6 = ctxt (0)
MOVD ·callbackWrap_call(SB), R3
MOVD (R3), R3 // dereference closure to get fn
ADD $CB_ARGS, R1, R4 // frame = &callbackArgs
MOVD $0, R6 // ctxt = 0
BL crosscall2(SB)
// Get callback result into R3
MOVD (CB_ARGS+16)(R1), R3
// Restore R31
MOVD SAVE_R31(R1), R31
// Deallocate frame
ADD $FRAME_SIZE, R1
// Restore LR from caller's frame (per ELFv2, it was saved at 16(old_R1))
MOVD 16(R1), R0
MOVD R0, LR
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_riscv64.s 0000664 0000000 0000000 00000004203 15207302613 0023351 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
TEXT callbackasm1(SB), NOFRAME, $0
NO_LOCAL_POINTERS
// On entry, the trampoline in zcallback_riscv64.s left
// the callback index in X7.
// Save callback register arguments X10-X17 and F10-F17.
// Stack args (if any) are at 0(SP), 8(SP), etc.
// We save register args at SP-128, making them contiguous with stack args.
ADD $-(16*8), SP, X6
// Save float arg regs fa0-fa7 (F10-F17)
MOVD F10, 0(X6)
MOVD F11, 8(X6)
MOVD F12, 16(X6)
MOVD F13, 24(X6)
MOVD F14, 32(X6)
MOVD F15, 40(X6)
MOVD F16, 48(X6)
MOVD F17, 56(X6)
// Save integer arg regs a0-a7 (X10-X17)
MOV X10, 64(X6)
MOV X11, 72(X6)
MOV X12, 80(X6)
MOV X13, 88(X6)
MOV X14, 96(X6)
MOV X15, 104(X6)
MOV X16, 112(X6)
MOV X17, 120(X6)
// Allocate space on stack for RA, saved regs, and callbackArgs.
// We need: 8 (RA) + 8 (X9 callee-saved) + 24 (callbackArgs) = 40, round to 176 (22*8)
// to match loong64 and ensure we don't overlap with saved register args.
// The saved regs end at SP-8 (original), so we need new SP below SP-128.
ADD $-(22*8), SP
// Save link register (RA/X1) and callee-saved register X9
// (X9 is used by the assembler for some instructions)
MOV X1, 0(SP)
MOV X9, 8(SP)
// Create a struct callbackArgs on our stack.
// callbackArgs struct: index(0), args(8), result(16)
// Place it at 16(SP) to avoid overlap
ADD $16, SP, X9
MOV X7, 0(X9) // callback index
MOV X6, 8(X9) // address of args vector
MOV X0, 16(X9) // result = 0
// Call crosscall2 with arguments in registers
MOV ·callbackWrap_call(SB), X10 // Get the ABIInternal function pointer
MOV (X10), X10 // without by using a closure. X10 = fn
MOV X9, X11 // X11 = frame (address of callbackArgs)
MOV X0, X13 // X13 = ctxt = 0
CALL crosscall2(SB)
// Get callback result.
ADD $16, SP, X9
MOV 16(X9), X10
// Restore link register and callee-saved X9
MOV 8(SP), X9
MOV 0(SP), X1
// Restore stack pointer
ADD $(22*8), SP
RET
golang-github-ebitengine-purego-0.10.1/sys_unix_s390x.s 0000664 0000000 0000000 00000006637 15207302613 0022754 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux
#include "textflag.h"
#include "go_asm.h"
#include "funcdata.h"
// S390X ELF ABI callbackasm1 implementation
// On entry, R0 contains the callback index (set by callbackasm)
// NOTE: We use R0 instead of R11 because R11 is callee-saved on S390X.
//
// S390X stack frame layout:
// 0(R15) - back chain
// 48(R15) - register save area (R6-R15)
// 160(R15) - parameter area
//
// S390X uses R2-R6 for integer arguments (5 registers) and F0,F2,F4,F6 for floats (4 registers).
//
// Our frame layout (total 264 bytes, 8-byte aligned):
// 0(R15) - back chain
// 48(R15) - saved R6-R15 (done by STMG)
// 160(R15) - callbackArgs struct (32 bytes: index, args, result, stackArgs)
// 192(R15) - args array start
//
// Args array layout:
// - floats F0,F2,F4,F6 (32 bytes)
// - ints R2-R6 (40 bytes)
// Total args array: 72 bytes, ends at 264
//
// Stack args in caller's frame start at old_R15+160
#define FRAME_SIZE 264
#define CB_ARGS 160
#define ARGS_ARRAY 192
#define FLOAT_OFF 0
#define INT_OFF 32
TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
NO_LOCAL_POINTERS
// On entry, the trampoline in zcallback_s390x.s left
// the callback index in R0 (NOT R11, since R11 is callee-saved).
// R6 contains the 5th integer argument.
// Save R6-R15 in caller's frame (per S390X ABI) BEFORE allocating our frame
// STMG stores R6's current value (the 5th arg) at 48(R15)
STMG R6, R15, 48(R15)
// Save current stack pointer (will be back chain)
MOVD R15, R1
// Allocate our stack frame
SUB $FRAME_SIZE, R15
MOVD R1, 0(R15) // back chain
// Save R0 (callback index) immediately - it's volatile
MOVD R0, (CB_ARGS+0)(R15)
// Save callback arguments to args array.
// Layout: floats first (F0,F2,F4,F6), then ints (R2-R6)
FMOVD F0, (ARGS_ARRAY+FLOAT_OFF+0*8)(R15)
FMOVD F2, (ARGS_ARRAY+FLOAT_OFF+1*8)(R15)
FMOVD F4, (ARGS_ARRAY+FLOAT_OFF+2*8)(R15)
FMOVD F6, (ARGS_ARRAY+FLOAT_OFF+3*8)(R15)
MOVD R2, (ARGS_ARRAY+INT_OFF+0*8)(R15)
MOVD R3, (ARGS_ARRAY+INT_OFF+1*8)(R15)
MOVD R4, (ARGS_ARRAY+INT_OFF+2*8)(R15)
MOVD R5, (ARGS_ARRAY+INT_OFF+3*8)(R15)
// R6 (5th int arg) was saved at 48(old_R15) by STMG
// old_R15 = current R15 + FRAME_SIZE, so R6 is at 48+FRAME_SIZE(R15) = 312(R15)
MOVD (48+FRAME_SIZE)(R15), R1
MOVD R1, (ARGS_ARRAY+INT_OFF+4*8)(R15)
// Finish setting up callbackArgs struct at CB_ARGS(R15)
// struct { index uintptr; args unsafe.Pointer; result uintptr; stackArgs unsafe.Pointer }
// Note: index was already saved earlier
ADD $ARGS_ARRAY, R15, R1
MOVD R1, (CB_ARGS+8)(R15) // args = address of register args
MOVD $0, (CB_ARGS+16)(R15) // result = 0
// stackArgs points to caller's stack arguments at old_R15+160 = R15+FRAME_SIZE+160
ADD $(FRAME_SIZE+160), R15, R1
MOVD R1, (CB_ARGS+24)(R15) // stackArgs = &caller_stack_args
// Call crosscall2 with arguments in registers:
// R2 = fn (from callbackWrap_call closure)
// R3 = frame (address of callbackArgs)
// R5 = ctxt (0)
MOVD ·callbackWrap_call(SB), R2
MOVD (R2), R2 // dereference closure to get fn
ADD $CB_ARGS, R15, R3 // frame = &callbackArgs
MOVD $0, R5 // ctxt = 0
BL crosscall2(SB)
// Get callback result into R2
MOVD (CB_ARGS+16)(R15), R2
// Deallocate frame
ADD $FRAME_SIZE, R15
// Restore R6-R15 from caller's frame
LMG 48(R15), R6, R15
RET
golang-github-ebitengine-purego-0.10.1/syscall.go 0000664 0000000 0000000 00000005355 15207302613 0021736 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build !386 && !arm && (darwin || freebsd || linux || netbsd || windows)
package purego
// CDecl marks a function as being called using the __cdecl calling convention as defined in
// the [MSDocs] when passed to NewCallback. It must be the first argument to the function.
// This is only useful on 386 Windows, but it is safe to use on other platforms.
//
// [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
type CDecl struct{}
const (
maxArgs = 15
)
type syscall15Args struct {
fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
f1, f2, f3, f4, f5, f6, f7, f8 uintptr
arm64_r8 uintptr
}
func (s *syscall15Args) Set(fn uintptr, ints []uintptr, floats []uintptr, r8 uintptr) {
s.fn = fn
s.a1 = ints[0]
s.a2 = ints[1]
s.a3 = ints[2]
s.a4 = ints[3]
s.a5 = ints[4]
s.a6 = ints[5]
s.a7 = ints[6]
s.a8 = ints[7]
s.a9 = ints[8]
s.a10 = ints[9]
s.a11 = ints[10]
s.a12 = ints[11]
s.a13 = ints[12]
s.a14 = ints[13]
s.a15 = ints[14]
s.f1 = floats[0]
s.f2 = floats[1]
s.f3 = floats[2]
s.f4 = floats[3]
s.f5 = floats[4]
s.f6 = floats[5]
s.f7 = floats[6]
s.f8 = floats[7]
s.arm64_r8 = r8
}
// SyscallN takes fn, a C function pointer and a list of arguments as uintptr.
// There is an internal maximum number of arguments that SyscallN can take. It panics
// when the maximum is exceeded. It returns the result and the libc error code if there is one.
//
// In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer]
// especially point 4.
//
// NOTE: SyscallN does not properly call functions that have both integer and float parameters.
// See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607
// for an explanation of why that is.
//
// On amd64, if there are more than 8 floats the 9th and so on will be placed incorrectly on the
// stack.
//
// The pragma go:nosplit is not needed at this function declaration because it uses go:uintptrescapes
// which forces all the objects that the uintptrs point to onto the heap where a stack split won't affect
// their memory location.
//
//go:uintptrescapes
func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
if fn == 0 {
panic("purego: fn is nil")
}
if len(args) > maxArgs {
panic("purego: too many arguments to SyscallN")
}
// add padding so there is no out-of-bounds slicing
var tmp [maxArgs]uintptr
copy(tmp[:], args)
return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14])
}
golang-github-ebitengine-purego-0.10.1/syscall_32bit.go 0000664 0000000 0000000 00000006474 15207302613 0022744 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build (386 || arm) && (freebsd || linux || netbsd || windows)
package purego
// CDecl marks a function as being called using the __cdecl calling convention as defined in
// the [MSDocs] when passed to NewCallback. It must be the first argument to the function.
// This is only useful on 386 Windows, but it is safe to use on other platforms.
//
// [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
type CDecl struct{}
const (
maxArgs = 32
)
type syscall15Args struct {
fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32 uintptr
f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16 uintptr
arm64_r8 uintptr
}
func (s *syscall15Args) Set(fn uintptr, ints []uintptr, floats []uintptr, r8 uintptr) {
s.fn = fn
s.a1 = ints[0]
s.a2 = ints[1]
s.a3 = ints[2]
s.a4 = ints[3]
s.a5 = ints[4]
s.a6 = ints[5]
s.a7 = ints[6]
s.a8 = ints[7]
s.a9 = ints[8]
s.a10 = ints[9]
s.a11 = ints[10]
s.a12 = ints[11]
s.a13 = ints[12]
s.a14 = ints[13]
s.a15 = ints[14]
s.a16 = ints[15]
s.a17 = ints[16]
s.a18 = ints[17]
s.a19 = ints[18]
s.a20 = ints[19]
s.a21 = ints[20]
s.a22 = ints[21]
s.a23 = ints[22]
s.a24 = ints[23]
s.a25 = ints[24]
s.a26 = ints[25]
s.a27 = ints[26]
s.a28 = ints[27]
s.a29 = ints[28]
s.a30 = ints[29]
s.a31 = ints[30]
s.a32 = ints[31]
s.f1 = floats[0]
s.f2 = floats[1]
s.f3 = floats[2]
s.f4 = floats[3]
s.f5 = floats[4]
s.f6 = floats[5]
s.f7 = floats[6]
s.f8 = floats[7]
s.f9 = floats[8]
s.f10 = floats[9]
s.f11 = floats[10]
s.f12 = floats[11]
s.f13 = floats[12]
s.f14 = floats[13]
s.f15 = floats[14]
s.f16 = floats[15]
s.arm64_r8 = r8
}
// SyscallN takes fn, a C function pointer and a list of arguments as uintptr.
// There is an internal maximum number of arguments that SyscallN can take. It panics
// when the maximum is exceeded. It returns the result and the libc error code if there is one.
//
// In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer]
// especially point 4.
//
// NOTE: SyscallN does not properly call functions that have both integer and float parameters.
// See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607
// for an explanation of why that is.
//
// On amd64, if there are more than 8 floats the 9th and so on will be placed incorrectly on the
// stack.
//
// The pragma go:nosplit is not needed at this function declaration because it uses go:uintptrescapes
// which forces all the objects that the uintptrs point to onto the heap where a stack split won't affect
// their memory location.
//
//go:uintptrescapes
func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
if fn == 0 {
panic("purego: fn is nil")
}
if len(args) > maxArgs {
panic("purego: too many arguments to SyscallN")
}
// add padding so there is no out-of-bounds slicing
var tmp [maxArgs]uintptr
copy(tmp[:], args)
return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14])
}
golang-github-ebitengine-purego-0.10.1/syscall_bench_test.go 0000664 0000000 0000000 00000021256 15207302613 0024132 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
package purego_test
import (
"fmt"
"os"
"path/filepath"
"testing"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/internal/load"
)
// BenchmarkCallingMethods compares RegisterFunc, SyscallN, and Callback methods
func BenchmarkCallingMethods(b *testing.B) {
testCases := []struct {
n int
goFn any
goFnPtr uintptr
cFnPtr uintptr
cFnName string
cCallbackPtr uintptr
cCallbackName string
args []int64
expectedSum int64
}{
{1, goSum1, 0, 0, "sum1_c", 0, "call_callback1", []int64{1}, 1},
{2, goSum2, 0, 0, "sum2_c", 0, "call_callback2", []int64{1, 2}, 3},
{3, goSum3, 0, 0, "sum3_c", 0, "call_callback3", []int64{1, 2, 3}, 6},
{5, goSum5, 0, 0, "sum5_c", 0, "call_callback5", []int64{1, 2, 3, 4, 5}, 15},
{10, goSum10, 0, 0, "sum10_c", 0, "call_callback10", []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 55},
{14, goSum15, 0, 0, "sum14_c", 0, "call_callback14", []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 105},
{15, goSum15, 0, 0, "sum15_c", 0, "call_callback15", []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, 120},
}
// Build C library for benchmarking
libFileName := filepath.Join(b.TempDir(), "libbenchmark.so")
if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "benchmarktest", "benchmark.c")); err != nil {
b.Fatalf("Failed to build C library: %v", err)
}
b.Cleanup(func() {
os.Remove(libFileName)
})
libHandle, err := load.OpenLibrary(libFileName)
if err != nil {
b.Fatalf("Failed to load C library: %v", err)
}
b.Cleanup(func() {
if err := load.CloseLibrary(libHandle); err != nil {
b.Fatalf("Failed to close library: %s", err)
}
})
// Create callbacks and load C functions
for i := range testCases {
testCases[i].goFnPtr = purego.NewCallback(testCases[i].goFn)
cFn, err := load.OpenSymbol(libHandle, testCases[i].cFnName)
if err != nil {
b.Fatalf("Failed to load C function %s: %v", testCases[i].cFnName, err)
}
testCases[i].cFnPtr = cFn
cCallbackFn, err := load.OpenSymbol(libHandle, testCases[i].cCallbackName)
if err != nil {
b.Fatalf("Failed to load C callback wrapper %s: %v", testCases[i].cCallbackName, err)
}
testCases[i].cCallbackPtr = cCallbackFn
}
b.Run("RegisterFunc/Callback", func(b *testing.B) {
for _, tc := range testCases {
b.Run(fmt.Sprintf("%dargs", tc.n), func(b *testing.B) {
b.ReportAllocs()
registerFn := makeRegisterFunc(tc.n)
purego.RegisterFunc(registerFn, tc.goFnPtr)
b.ResetTimer()
result := callRegisterFunc(registerFn, tc.n, tc.args, b.N)
b.StopTimer()
if result != tc.expectedSum {
b.Fatalf("RegisterFunc/Callback: expected sum %d, got %d", tc.expectedSum, result)
}
})
}
})
// Benchmark RegisterFunc with C functions
b.Run("RegisterFunc/CFunc", func(b *testing.B) {
for _, tc := range testCases {
b.Run(fmt.Sprintf("%dargs", tc.n), func(b *testing.B) {
b.ReportAllocs()
registerFn := makeRegisterFunc(tc.n)
purego.RegisterFunc(registerFn, tc.cFnPtr)
b.ResetTimer()
result := callRegisterFunc(registerFn, tc.n, tc.args, b.N)
b.StopTimer()
if result != tc.expectedSum {
b.Fatalf("RegisterFunc/CFunc: expected sum %d, got %d", tc.expectedSum, result)
}
})
}
})
// Benchmark SyscallN with Go callbacks
b.Run("SyscallN/Callback", func(b *testing.B) {
for _, tc := range testCases {
b.Run(fmt.Sprintf("%dargs", tc.n), func(b *testing.B) {
b.ReportAllocs()
args := int64sToUintptrs(tc.args)
var result uintptr
b.ResetTimer()
for i := 0; i < b.N; i++ {
result, _, _ = purego.SyscallN(tc.goFnPtr, args...)
}
b.StopTimer()
if int64(result) != tc.expectedSum {
b.Fatalf("SyscallN/Callback: expected sum %d, got %d", tc.expectedSum, result)
}
})
}
})
// Benchmark SyscallN with C functions
b.Run("SyscallN/CFunc", func(b *testing.B) {
for _, tc := range testCases {
b.Run(fmt.Sprintf("%dargs", tc.n), func(b *testing.B) {
b.ReportAllocs()
args := int64sToUintptrs(tc.args)
var result uintptr
b.ResetTimer()
for i := 0; i < b.N; i++ {
result, _, _ = purego.SyscallN(tc.cFnPtr, args...)
}
b.StopTimer()
if int64(result) != tc.expectedSum {
b.Fatalf("SyscallN/CFunc: expected sum %d, got %d", tc.expectedSum, result)
}
})
}
})
// Benchmark round-trip: Go → C → Go callback (realistic use case)
b.Run("RoundTrip/GoC", func(b *testing.B) {
for _, tc := range testCases {
b.Run(fmt.Sprintf("%dargs", tc.n), func(b *testing.B) {
b.ReportAllocs()
// Build args: first arg is callback pointer, rest are the arguments
args := int64sToUintptrs(tc.args)
callbackArgs := make([]uintptr, len(args)+1)
callbackArgs[0] = tc.goFnPtr
copy(callbackArgs[1:], args)
// Skip if total args (callback + args) exceeds or meets limit
// SyscallN has issues with exactly 15 or more arguments
if len(callbackArgs) >= 15 {
b.Skipf("Round-trip with %d args + callback (%d total) exceeds/meets SyscallN limit", tc.n, len(callbackArgs))
}
var result uintptr
b.ResetTimer()
for i := 0; i < b.N; i++ {
result, _, _ = purego.SyscallN(tc.cCallbackPtr, callbackArgs...)
}
b.StopTimer()
if int64(result) != tc.expectedSum {
b.Fatalf("RoundTrip: expected sum %d, got %d", tc.expectedSum, result)
}
})
}
})
}
// makeRegisterFunc creates a function pointer of the appropriate signature
func makeRegisterFunc(n int) any {
switch n {
case 1:
return new(func(int64) int64)
case 2:
return new(func(int64, int64) int64)
case 3:
return new(func(int64, int64, int64) int64)
case 5:
return new(func(int64, int64, int64, int64, int64) int64)
case 10:
return new(func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
case 14:
return new(func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
case 15:
return new(func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
default:
panic(fmt.Sprintf("unsupported arg count: %d", n))
}
}
// callRegisterFunc calls the registered function with the appropriate number of arguments
func callRegisterFunc(registerFn any, n int, args []int64, iterations int) int64 {
var result int64
switch n {
case 1:
f := registerFn.(*func(int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0])
}
case 2:
f := registerFn.(*func(int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1])
}
case 3:
f := registerFn.(*func(int64, int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1], args[2])
}
case 5:
f := registerFn.(*func(int64, int64, int64, int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1], args[2], args[3], args[4])
}
case 10:
f := registerFn.(*func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args[9])
}
case 14:
f := registerFn.(*func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args[9],
args[10], args[11], args[12], args[13])
}
case 15:
f := registerFn.(*func(int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64, int64) int64)
for i := 0; i < iterations; i++ {
result = (*f)(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args[9],
args[10], args[11], args[12], args[13], args[14])
}
default:
panic(fmt.Sprintf("unsupported arg count: %d", n))
}
return result
}
// int64sToUintptrs converts []int64 to []uintptr for SyscallN
func int64sToUintptrs(args []int64) []uintptr {
result := make([]uintptr, len(args))
for i, v := range args {
result[i] = uintptr(v)
}
return result
}
func goSum1(a1 int64) int64 { return a1 }
func goSum2(a1, a2 int64) int64 { return a1 + a2 }
func goSum3(a1, a2, a3 int64) int64 { return a1 + a2 + a3 }
func goSum5(a1, a2, a3, a4, a5 int64) int64 { return a1 + a2 + a3 + a4 + a5 }
func goSum10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 int64) int64 {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10
}
func goSum15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int64) int64 {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15
}
golang-github-ebitengine-purego-0.10.1/syscall_cgo_linux.go 0000664 0000000 0000000 00000001264 15207302613 0024000 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
//go:build cgo && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || s390x)
package purego
import (
"github.com/ebitengine/purego/internal/cgo"
)
var syscall15XABI0 = uintptr(cgo.Syscall15XABI0)
//go:nosplit
func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
}
func NewCallback(_ any) uintptr {
panic("purego: NewCallback on Linux is only supported on 386/amd64/arm64/arm/loong64/ppc64le/riscv64/s390x")
}
golang-github-ebitengine-purego-0.10.1/syscall_sysv.go 0000664 0000000 0000000 00000027032 15207302613 0023016 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
// TODO: remove s390x cgo dependency once golang/go#77449 is resolved
//go:build darwin || freebsd || (linux && (386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || (cgo && s390x))) || netbsd
package purego
import (
"reflect"
"runtime"
"sync"
"unsafe"
)
var syscall15XABI0 uintptr
func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
args := &syscall15Args{
fn: fn,
a1: a1, a2: a2, a3: a3, a4: a4, a5: a5, a6: a6, a7: a7, a8: a8,
a9: a9, a10: a10, a11: a11, a12: a12, a13: a13, a14: a14, a15: a15,
f1: a1, f2: a2, f3: a3, f4: a4, f5: a5, f6: a6, f7: a7, f8: a8,
}
runtime_cgocall(syscall15XABI0, unsafe.Pointer(args))
return args.a1, args.a2, args.a3
}
// NewCallback converts a Go function to a function pointer conforming to the C calling convention.
// This is useful when interoperating with C code requiring callbacks. The argument is expected to be a
// function with zero or one uintptr-sized result. The function must not have arguments with size larger than the size
// of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory allocated
// for these callbacks is never released. At least 2000 callbacks can always be created. Although this function
// provides similar functionality to windows.NewCallback it is distinct.
func NewCallback(fn any) uintptr {
ty := reflect.TypeOf(fn)
for i := 0; i < ty.NumIn(); i++ {
in := ty.In(i)
if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
continue
}
if i != 0 {
panic("purego: CDecl must be the first argument")
}
}
return compileCallback(fn)
}
// maxCb is the maximum number of callbacks
// only increase this if you have added more to the callbackasm function
const maxCB = 2000
var cbs struct {
lock sync.Mutex
numFn int // the number of functions currently in cbs.funcs
funcs [maxCB]reflect.Value // the saved callbacks
}
func compileCallback(fn any) uintptr {
val := reflect.ValueOf(fn)
if val.Kind() != reflect.Func {
panic("purego: the type must be a function but was not")
}
if val.IsNil() {
panic("purego: function must not be nil")
}
ty := val.Type()
for i := 0; i < ty.NumIn(); i++ {
in := ty.In(i)
switch in.Kind() {
case reflect.Struct:
if i == 0 && in.AssignableTo(reflect.TypeOf(CDecl{})) {
continue
}
fallthrough
case reflect.Interface, reflect.Func, reflect.Slice,
reflect.Chan, reflect.Complex64, reflect.Complex128,
reflect.String, reflect.Map, reflect.Invalid:
panic("purego: unsupported argument type: " + in.Kind().String())
}
}
output:
switch {
case ty.NumOut() == 1:
switch ty.Out(0).Kind() {
case reflect.Pointer, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
reflect.Bool, reflect.UnsafePointer:
break output
}
panic("purego: unsupported return type: " + ty.String())
case ty.NumOut() > 1:
panic("purego: callbacks can only have one return")
}
cbs.lock.Lock()
defer cbs.lock.Unlock()
if cbs.numFn >= maxCB {
panic("purego: the maximum number of callbacks has been reached")
}
cbs.funcs[cbs.numFn] = val
cbs.numFn++
return callbackasmAddr(cbs.numFn - 1)
}
const ptrSize = unsafe.Sizeof((*int)(nil))
const callbackMaxFrame = 64 * ptrSize
// callbackasm is implemented in zcallback_GOOS_GOARCH.s
//
//go:linkname __callbackasm callbackasm
var __callbackasm byte
var callbackasmABI0 = uintptr(unsafe.Pointer(&__callbackasm))
// callbackWrap_call allows the calling of the ABIInternal wrapper
// which is required for runtime.cgocallback without the
// tag which is only allowed in the runtime.
// This closure is used inside sys_darwin_GOARCH.s
var callbackWrap_call = callbackWrap
// callbackWrap is called by assembly code which determines which Go function to call.
// This function takes the arguments and passes them to the Go function and returns the result.
func callbackWrap(a *callbackArgs) {
cbs.lock.Lock()
fn := cbs.funcs[a.index]
cbs.lock.Unlock()
fnType := fn.Type()
args := make([]reflect.Value, fnType.NumIn())
frame := (*[callbackMaxFrame]uintptr)(a.args)
// stackFrame points to stack-passed arguments. On most architectures this is
// contiguous with frame (after register args), but on ppc64le it's separate.
var stackFrame *[callbackMaxFrame]uintptr
if sf := a.stackFrame(); sf != nil {
// Only ppc64le uses separate stackArgs pointer due to NOSPLIT constraints
stackFrame = (*[callbackMaxFrame]uintptr)(sf)
}
// floatsN and intsN track the number of register slots used, not argument count.
// This distinction matters on ARM32 where float64 uses 2 slots (32-bit registers).
var floatsN int
var intsN int
// stackSlot points to the index into frame (or stackFrame) of the current stack element.
// When stackFrame is nil, stack begins after float and integer registers in frame.
// When stackFrame is not nil (ppc64le), stackSlot indexes into stackFrame starting at 0.
stackSlot := numOfIntegerRegisters() + numOfFloatRegisters()
if stackFrame != nil {
// ppc64le: stackArgs is a separate pointer, indices start at 0
stackSlot = 0
}
// stackByteOffset tracks the byte offset within the stack area for Darwin ARM64
// tight packing. On Darwin ARM64, C passes small types packed on the stack.
stackByteOffset := uintptr(0)
for i := range args {
// slots is the number of pointer-sized slots the argument takes
var slots int
inType := fnType.In(i)
switch inType.Kind() {
case reflect.Float32, reflect.Float64:
slots = int((fnType.In(i).Size() + ptrSize - 1) / ptrSize)
if floatsN+slots > numOfFloatRegisters() {
if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
// Darwin ARM64: read from packed stack with proper alignment
args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType)
} else if stackFrame != nil {
// ppc64le/s390x: stack args are in separate stackFrame
if runtime.GOARCH == "s390x" {
// s390x big-endian: sub-8-byte values are right-justified
args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&stackFrame[stackSlot]), inType)
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem()
}
stackSlot += slots
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem()
stackSlot += slots
}
} else {
if runtime.GOARCH == "s390x" {
// s390x big-endian: float32 is right-justified in 8-byte FPR slot
args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&frame[floatsN]), inType)
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[floatsN])).Elem()
}
}
floatsN += slots
case reflect.Struct:
// This is the CDecl field
args[i] = reflect.Zero(inType)
default:
slots = int((inType.Size() + ptrSize - 1) / ptrSize)
if intsN+slots > numOfIntegerRegisters() {
if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
// Darwin ARM64: read from packed stack with proper alignment
args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType)
} else if stackFrame != nil {
// ppc64le/s390x: stack args are in separate stackFrame
if runtime.GOARCH == "s390x" {
// s390x big-endian: sub-8-byte values are right-justified
args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&stackFrame[stackSlot]), inType)
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem()
}
stackSlot += slots
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem()
stackSlot += slots
}
} else {
// the integers begin after the floats in frame
pos := intsN + numOfFloatRegisters()
if runtime.GOARCH == "s390x" {
// s390x big-endian: sub-8-byte values are right-justified in GPR slot
args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&frame[pos]), inType)
} else {
args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[pos])).Elem()
}
}
intsN += slots
}
}
ret := fn.Call(args)
if len(ret) > 0 {
switch k := ret[0].Kind(); k {
case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uintptr:
a.result = uintptr(ret[0].Uint())
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8:
a.result = uintptr(ret[0].Int())
case reflect.Bool:
if ret[0].Bool() {
a.result = 1
} else {
a.result = 0
}
case reflect.Pointer:
a.result = ret[0].Pointer()
case reflect.UnsafePointer:
a.result = ret[0].Pointer()
default:
panic("purego: unsupported kind: " + k.String())
}
}
}
// callbackArgFromStack reads an argument from the tightly-packed stack area on Darwin ARM64.
// The C ABI on Darwin ARM64 packs small types on the stack without padding to 8 bytes.
// This function handles proper alignment and advances stackByteOffset accordingly.
func callbackArgFromStack(argsBase unsafe.Pointer, stackSlot int, stackByteOffset *uintptr, inType reflect.Type) reflect.Value {
// Calculate base address of stack area (after float and int registers)
stackBase := unsafe.Add(argsBase, stackSlot*int(ptrSize))
// Get type's natural alignment
align := uintptr(inType.Align())
size := inType.Size()
// Align the offset
if *stackByteOffset%align != 0 {
*stackByteOffset = (*stackByteOffset + align - 1) &^ (align - 1)
}
// Read value at aligned offset
ptr := unsafe.Add(stackBase, *stackByteOffset)
*stackByteOffset += size
return reflect.NewAt(inType, ptr).Elem()
}
// callbackArgFromSlotBigEndian reads an argument from an 8-byte slot on big-endian architectures.
// On s390x:
// - Integer types are right-justified in GPRs: sub-8-byte values are at offset (8 - size)
// - Float32 in FPRs is left-justified: stored in upper 32 bits, so at offset 0
// - Float64 occupies the full 8-byte slot
func callbackArgFromSlotBigEndian(slotPtr unsafe.Pointer, inType reflect.Type) reflect.Value {
size := inType.Size()
if size >= 8 {
// 8-byte values occupy the entire slot
return reflect.NewAt(inType, slotPtr).Elem()
}
// Float32 is left-justified in FPRs (upper 32 bits), so offset is 0
if inType.Kind() == reflect.Float32 {
return reflect.NewAt(inType, slotPtr).Elem()
}
// Integer types are right-justified: offset = 8 - size
offset := 8 - size
ptr := unsafe.Add(slotPtr, offset)
return reflect.NewAt(inType, ptr).Elem()
}
// callbackasmAddr returns address of runtime.callbackasm
// function adjusted by i.
// On x86 and amd64, runtime.callbackasm is a series of CALL instructions,
// and we want callback to arrive at
// correspondent call instruction instead of start of
// runtime.callbackasm.
// On ARM, runtime.callbackasm is a series of mov and branch instructions.
// R12 is loaded with the callback index. Each entry is two instructions,
// hence 8 bytes.
func callbackasmAddr(i int) uintptr {
var entrySize int
switch runtime.GOARCH {
default:
panic("purego: unsupported architecture")
case "amd64":
// On amd64, each callback entry is just a CALL instruction (5 bytes)
entrySize = 5
case "386":
// On 386, each callback entry is MOVL $imm, CX (5 bytes) + JMP (5 bytes)
entrySize = 10
case "arm", "arm64", "loong64", "ppc64le", "riscv64":
// On ARM, ARM64, Loong64, PPC64LE and RISCV64, each entry is a MOV instruction
// followed by a branch instruction
entrySize = 8
case "s390x":
// On S390X, each entry is LGHI (4 bytes) + JG (6 bytes)
entrySize = 10
}
return callbackasmABI0 + uintptr(i*entrySize)
}
golang-github-ebitengine-purego-0.10.1/syscall_sysv_others.go 0000664 0000000 0000000 00000001311 15207302613 0024372 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build darwin || freebsd || (linux && (386 || amd64 || arm || arm64 || loong64 || riscv64)) || netbsd
package purego
import "unsafe"
type callbackArgs struct {
index uintptr
// args points to the argument block.
//
// The structure of the arguments goes
// float registers followed by the
// integer registers followed by the stack.
//
// This variable is treated as a continuous
// block of memory containing all of the arguments
// for this callback.
args unsafe.Pointer
// Below are out-args from callbackWrap
result uintptr
}
func (c *callbackArgs) stackFrame() unsafe.Pointer {
return nil
}
golang-github-ebitengine-purego-0.10.1/syscall_sysv_stackargs.go 0000664 0000000 0000000 00000001631 15207302613 0025055 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
//go:build linux && (ppc64le || s390x)
package purego
import "unsafe"
type callbackArgs struct {
index uintptr
// args points to the argument block.
//
// The structure of the arguments goes
// float registers followed by the
// integer registers followed by the stack.
//
// This variable is treated as a continuous
// block of memory containing all of the arguments
// for this callback.
args unsafe.Pointer
// Below are out-args from callbackWrap
result uintptr
// stackArgs points to stack-passed arguments for architectures where
// they can't be made contiguous with register args (e.g., ppc64le).
// On other architectures, this is nil and stack args are read from
// the end of the args block.
stackArgs unsafe.Pointer
}
func (c *callbackArgs) stackFrame() unsafe.Pointer {
return c.stackArgs
}
golang-github-ebitengine-purego-0.10.1/syscall_test.go 0000664 0000000 0000000 00000002445 15207302613 0022772 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
package purego_test
import (
"os"
"runtime"
"testing"
"unsafe"
"github.com/ebitengine/purego"
"github.com/ebitengine/purego/internal/load"
)
func TestOS(t *testing.T) {
// set and unset an environment variable since this calls into fakecgo.
err := os.Setenv("TESTING", "SOMETHING")
if err != nil {
t.Errorf("failed to Setenv: %s", err)
}
err = os.Unsetenv("TESTING")
if err != nil {
t.Errorf("failed to Unsetenv: %s", err)
}
}
func TestErrno(t *testing.T) {
if runtime.GOOS != "darwin" {
t.Skip("platform does not support returning errno from syscall")
}
libc, err := load.OpenLibrary("/usr/lib/libSystem.B.dylib")
if err != nil {
t.Fatal(err)
}
openSym, err := load.OpenSymbol(libc, "open")
if err != nil {
t.Fatal(err)
}
r1, _, errno := purego.SyscallN(openSym, uintptr(unsafe.Pointer(&[]byte("_file_that_does_not_exist_\x00")[0])), uintptr(os.O_RDWR))
if int32(r1) != -1 {
t.Errorf("open returned %d, wanted -1", r1)
}
var strerror func(int32) string
purego.RegisterLibFunc(&strerror, libc, "strerror")
const expected = "No such file or directory"
got := strerror(int32(errno))
if got != expected {
t.Errorf("strerror returned %q, wanted \"%s\"", got, expected)
}
}
golang-github-ebitengine-purego-0.10.1/syscall_windows.go 0000664 0000000 0000000 00000003106 15207302613 0023500 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
package purego
import (
"reflect"
"syscall"
)
var syscall15XABI0 uintptr
func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
return r1, r2, uintptr(errno)
}
// NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention.
// This is useful when interoperating with Windows code requiring callbacks. The argument is expected to be a
// function with one uintptr-sized result. The function must not have arguments with size larger than the
// size of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory
// allocated for these callbacks is never released. Between NewCallback and NewCallbackCDecl, at least 1024
// callbacks can always be created. Although this function is similiar to the darwin version it may act
// differently.
func NewCallback(fn any) uintptr {
isCDecl := false
ty := reflect.TypeOf(fn)
for i := 0; i < ty.NumIn(); i++ {
in := ty.In(i)
if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
continue
}
if i != 0 {
panic("purego: CDecl must be the first argument")
}
isCDecl = true
}
if isCDecl {
return syscall.NewCallbackCDecl(fn)
}
return syscall.NewCallback(fn)
}
func loadSymbol(handle uintptr, name string) (uintptr, error) {
return syscall.GetProcAddress(syscall.Handle(handle), name)
}
golang-github-ebitengine-purego-0.10.1/testdata/ 0000775 0000000 0000000 00000000000 15207302613 0021536 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/abitest/ 0000775 0000000 0000000 00000000000 15207302613 0023171 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/abitest/abi_test.c 0000664 0000000 0000000 00000015007 15207302613 0025132 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
#include
#include
#include
#include
#include
#include
uint32_t stack_uint8_t(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f, uint32_t g, uint32_t h, uint8_t i, uint8_t j, uint32_t k ) {
assert(i == 1);
assert(j == 2);
assert(k == 1024);
return a | b | c | d | e | f | g | h | (uint32_t)i | (uint32_t)j | k;
}
uint32_t reg_uint8_t(uint8_t a, uint8_t b, uint32_t c) {
assert(a == 1);
assert(b == 2);
assert(c == 1024);
return a | b | c;
}
uint32_t stack_string(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f, uint32_t g, uint32_t h, const char * i) {
assert(i != 0);
assert(strcmp(i, "test") == 0);
return a | b | c | d | e | f | g | h;
}
void stack_8i32_3strings(char* result, size_t size, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, const char* s1, const char* s2, const char* s3) {
snprintf(result, size, "%d:%d:%d:%d:%d:%d:%d:%d:%s:%s:%s", a1, a2, a3, a4, a5, a6, a7, a8, s1, s2, s3);
}
// HFA (Homogeneous Float Aggregate) struct with 2 floats
typedef struct {
float x;
float y;
} Float2;
// HFA struct with 4 floats
typedef struct {
float x;
float y;
float z;
float w;
} Float4;
// Non-HFA struct (mixed types)
typedef struct {
int32_t a;
float b;
} MixedStruct;
// Small struct that fits in one register
typedef struct {
int32_t x;
int32_t y;
} IntPair;
// Test: 8 int registers exhausted, then HFA struct on stack
void stack_8int_hfa2_stack(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, Float2 f) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%.1f:%.1f",
a1, a2, a3, a4, a5, a6, a7, a8, f.x, f.y);
}
// Test: 8 int registers exhausted, then multiple structs on stack
void stack_8int_2structs_stack(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, IntPair p1, IntPair p2) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
a1, a2, a3, a4, a5, a6, a7, a8, p1.x, p1.y, p2.x, p2.y);
}
// Test: 8 float registers exhausted, then HFA on stack
void stack_8float_hfa2_stack(char *buf, size_t bufsize, float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, Float2 f) {
snprintf(buf, bufsize, "%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f",
f1, f2, f3, f4, f5, f6, f7, f8, f.x, f.y);
}
// Test: mixed - int regs exhausted, float struct can still use float regs
void stack_8int_hfa2_floatregs(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, Float2 f) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%.1f:%.1f",
a1, a2, a3, a4, a5, a6, a7, a8, f.x, f.y);
}
// Test: primitives and struct interleaved on stack
void stack_8int_int_struct_int(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, int32_t a9, IntPair p, int32_t a10) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
a1, a2, a3, a4, a5, a6, a7, a8, a9, p.x, p.y, a10);
}
// Test: HFA4 struct on stack (4 floats)
void stack_8int_hfa4_stack(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, Float4 f) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%.1f:%.1f:%.1f:%.1f",
a1, a2, a3, a4, a5, a6, a7, a8, f.x, f.y, f.z, f.w);
}
// Test: mixed type struct on stack
void stack_8int_mixed_struct(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, MixedStruct m) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%.1f",
a1, a2, a3, a4, a5, a6, a7, a8, m.a, m.b);
}
void stack_10_int32(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, int32_t a9, int32_t a10) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
}
void stack_11_int32(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, int32_t a9, int32_t a10, int32_t a11) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
}
void stack_10_float32(char *buf, size_t bufsize, float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9, float f10) {
snprintf(buf, bufsize, "%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f",
f1, f2, f3, f4, f5, f6, f7, f8, f9, f10);
}
void stack_mixed_stack_4args(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, const char *s1, bool b1, int32_t a9, const char *s2) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%s:%d:%d:%s",
a1, a2, a3, a4, a5, a6, a7, a8, s1, b1, a9, s2);
}
void stack_20_int32(char *buf, size_t bufsize, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, int32_t a9, int32_t a10, int32_t a11, int32_t a12, int32_t a13, int32_t a14, int32_t a15, int32_t a16, int32_t a17, int32_t a18, int32_t a19, int32_t a20) {
snprintf(buf, bufsize, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
}
void stack_25_int64_exceeds(char *buf, size_t bufsize, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, int64_t a7, int64_t a8, int64_t a9, int64_t a10, int64_t a11, int64_t a12, int64_t a13, int64_t a14, int64_t a15, int64_t a16, int64_t a17, int64_t a18, int64_t a19, int64_t a20, int64_t a21, int64_t a22, int64_t a23, int64_t a24, int64_t a25) {
snprintf(buf, bufsize, "%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64 ":%" PRId64,
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25);
}
golang-github-ebitengine-purego-0.10.1/testdata/benchmarktest/ 0000775 0000000 0000000 00000000000 15207302613 0024370 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/benchmarktest/benchmark.c 0000664 0000000 0000000 00000006767 15207302613 0026506 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
#include
int64_t sum1_c(int64_t a1) { return a1; }
int64_t sum2_c(int64_t a1, int64_t a2) { return a1 + a2; }
int64_t sum3_c(int64_t a1, int64_t a2, int64_t a3) { return a1 + a2 + a3; }
int64_t sum5_c(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5) {
return a1 + a2 + a3 + a4 + a5;
}
int64_t sum10_c(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5,
int64_t a6, int64_t a7, int64_t a8, int64_t a9, int64_t a10) {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10;
}
int64_t sum14_c(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5,
int64_t a6, int64_t a7, int64_t a8, int64_t a9, int64_t a10,
int64_t a11, int64_t a12, int64_t a13, int64_t a14) {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 +
a14;
}
int64_t sum15_c(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5,
int64_t a6, int64_t a7, int64_t a8, int64_t a9, int64_t a10,
int64_t a11, int64_t a12, int64_t a13, int64_t a14,
int64_t a15) {
return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 +
a14 + a15;
}
typedef int64_t (*callback1_t)(int64_t);
int64_t call_callback1(callback1_t cb, int64_t a1) { return cb(a1); }
typedef int64_t (*callback2_t)(int64_t, int64_t);
int64_t call_callback2(callback2_t cb, int64_t a1, int64_t a2) {
return cb(a1, a2);
}
typedef int64_t (*callback3_t)(int64_t, int64_t, int64_t);
int64_t call_callback3(callback3_t cb, int64_t a1, int64_t a2, int64_t a3) {
return cb(a1, a2, a3);
}
typedef int64_t (*callback5_t)(int64_t, int64_t, int64_t, int64_t, int64_t);
int64_t call_callback5(callback5_t cb, int64_t a1, int64_t a2, int64_t a3,
int64_t a4, int64_t a5) {
return cb(a1, a2, a3, a4, a5);
}
typedef int64_t (*callback10_t)(int64_t, int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t, int64_t);
int64_t call_callback10(callback10_t cb, int64_t a1, int64_t a2, int64_t a3,
int64_t a4, int64_t a5, int64_t a6, int64_t a7,
int64_t a8, int64_t a9, int64_t a10) {
return cb(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
}
typedef int64_t (*callback14_t)(int64_t, int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t);
int64_t call_callback14(callback14_t cb, int64_t a1, int64_t a2, int64_t a3,
int64_t a4, int64_t a5, int64_t a6, int64_t a7,
int64_t a8, int64_t a9, int64_t a10, int64_t a11,
int64_t a12, int64_t a13, int64_t a14) {
return cb(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
}
typedef int64_t (*callback15_t)(int64_t, int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t, int64_t);
int64_t call_callback15(callback15_t cb, int64_t a1, int64_t a2, int64_t a3,
int64_t a4, int64_t a5, int64_t a6, int64_t a7,
int64_t a8, int64_t a9, int64_t a10, int64_t a11,
int64_t a12, int64_t a13, int64_t a14, int64_t a15) {
return cb(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
}
golang-github-ebitengine-purego-0.10.1/testdata/libcbtest/ 0000775 0000000 0000000 00000000000 15207302613 0023511 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/libcbtest/callback_packing_test.c 0000664 0000000 0000000 00000006467 15207302613 0030161 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 The Ebitengine Authors
#include
#include
// Test: 12 int32 arguments - fills 8 int registers, then 4 go to stack
// With tight packing, the 4 stack args pack into 16 bytes (4x4)
// Without tight packing, they would use 32 bytes (4x8)
typedef int32_t (*callback_12_int32)(int32_t, int32_t, int32_t, int32_t,
int32_t, int32_t, int32_t, int32_t,
int32_t, int32_t, int32_t, int32_t);
int32_t callCallback12Int32(const void *fp) {
// Using prime numbers to detect argument misalignment
return ((callback_12_int32)(fp))(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37);
}
// Test: mixed int64 and int32 arguments with stack spillover
// 8 int64s fill registers, then int32/int64/int32 go to stack
// Tests alignment handling when mixing sizes on stack
typedef int64_t (*callback_mixed_stack)(int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t,
int32_t, int64_t, int32_t);
int64_t callCallbackMixedStack(const void *fp) {
return ((callback_mixed_stack)(fp))(1, 2, 3, 4, 5, 6, 7, 8, 100, 200, 300);
}
// Test: various small types on stack
// 8 int64s fill registers, then bool/int8/uint8/int16/uint16/int32 go to stack
// Tests byte-level packing of different small types
typedef int64_t (*callback_small_types)(int64_t, int64_t, int64_t, int64_t,
int64_t, int64_t, int64_t, int64_t,
bool, int8_t, uint8_t, int16_t, uint16_t, int32_t);
int64_t callCallbackSmallTypes(const void *fp) {
return ((callback_small_types)(fp))(1, 2, 3, 4, 5, 6, 7, 8,
true, -42, 200, -1000, 50000, 123456);
}
// Test: 10 int32 arguments - simpler case
// 8 fill registers, 2 go to stack (8 bytes packed vs 16 unpacked)
typedef int32_t (*callback_10_int32)(int32_t, int32_t, int32_t, int32_t,
int32_t, int32_t, int32_t, int32_t,
int32_t, int32_t);
int32_t callCallback10Int32(const void *fp) {
return ((callback_10_int32)(fp))(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
// Test: 10 float64 arguments - fills 8 float registers, then 2 go to stack
// Callback returns int64 since purego callbacks don't support float returns
typedef int64_t (*callback_10_float64)(double, double, double, double,
double, double, double, double,
double, double);
int64_t callCallback10Float64(const void *fp) {
return ((callback_10_float64)(fp))(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5);
}
// Test: 12 float32 arguments - fills 8 float registers, then 4 go to stack
// Callback returns int64 since purego callbacks don't support float returns
typedef int64_t (*callback_12_float32)(float, float, float, float,
float, float, float, float,
float, float, float, float);
int64_t callCallback12Float32(const void *fp) {
return ((callback_12_float32)(fp))(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f);
}
golang-github-ebitengine-purego-0.10.1/testdata/libcbtest/callback_test.c 0000664 0000000 0000000 00000000610 15207302613 0026445 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
#include
typedef int (*callback)(const char *, int);
int callCallback(const void *fp, const char *s) {
// If the callback corrupts FP, this local variable on the stack will have incorrect value.
int sentinel = 10101;
((callback)(fp))(s, strlen(s));
return sentinel;
}
golang-github-ebitengine-purego-0.10.1/testdata/libdlnested/ 0000775 0000000 0000000 00000000000 15207302613 0024027 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/libdlnested/nested_test.cpp 0000664 0000000 0000000 00000000456 15207302613 0027061 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2023 The Ebitengine Authors
#include
struct nested_libdl
{
nested_libdl() {
// Fails for sure because a symbol cannot be named like this
dlsym(RTLD_DEFAULT, "@/*<>");
}
};
static nested_libdl test;
golang-github-ebitengine-purego-0.10.1/testdata/structtest/ 0000775 0000000 0000000 00000000000 15207302613 0023762 5 ustar 00root root 0000000 0000000 golang-github-ebitengine-purego-0.10.1/testdata/structtest/struct_test.c 0000664 0000000 0000000 00000017121 15207302613 0026513 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
#include
#include
#include
#if defined(__x86_64__) || defined(__aarch64__)
typedef int64_t GoInt;
typedef uint64_t GoUint;
#endif
// Empty is empty
struct Empty {};
// NoStruct tests that an empty struct doesn't cause issues
unsigned long NoStruct(struct Empty e) {
return 0xdeadbeef;
}
struct EmptyEmpty {
struct Empty x;
};
unsigned long EmptyEmpty(struct EmptyEmpty e) {
return 0xdeadbeef;
}
unsigned long EmptyEmptyWithReg(unsigned int x, struct EmptyEmpty e, unsigned int y) {
return (x << 16) | y;
}
// GreaterThan16Bytes is 24 bytes on 64 bit systems
struct GreaterThan16Bytes {
long *x, *y, *z;
};
// GreaterThan16Bytes is a basic test for structs bigger than 16 bytes
unsigned long GreaterThan16Bytes(struct GreaterThan16Bytes g) {
return *g.x + *g.y + *g.z;
}
// AfterRegisters tests to make sure that structs placed on the stack work properly
unsigned long AfterRegisters(long a, long b, long c, long d, long e, long f, long g, long h, struct GreaterThan16Bytes bytes) {
long registers = a + b + c + d + e + f + g + h;
long stack = *bytes.x + *bytes.y + *bytes.z;
if (registers != stack) {
return 0xbadbad;
}
if (stack != 0xdeadbeef) {
return 0xcafebad;
}
return stack;
}
unsigned long BeforeRegisters(struct GreaterThan16Bytes bytes, long a, long b) {
return *bytes.x + *bytes.y + *bytes.z + a + b;
}
struct GreaterThan16BytesStruct {
struct {
long *x, *y, *z;
} a ;
};
unsigned long GreaterThan16BytesStruct(struct GreaterThan16BytesStruct g) {
return *(g.a.x) + *(g.a.y) + *(g.a.z);
}
struct IntLessThan16Bytes {
long x, y;
};
unsigned long IntLessThan16Bytes(struct IntLessThan16Bytes l) {
return l.x + l.y;
}
struct FloatLessThan16Bytes {
float x, y;
};
float FloatLessThan16Bytes(struct FloatLessThan16Bytes f) {
return f.x + f.y;
}
struct ThreeSmallFields {
float x, y, z;
};
float ThreeSmallFields(struct ThreeSmallFields f) {
return f.x + f.y + f.z;
}
struct FloatAndInt {
float x;
int y;
};
float FloatAndInt(struct FloatAndInt f) {
return f.x + f.y;
}
struct DoubleStruct {
double x;
};
double DoubleStruct(struct DoubleStruct d) {
return d.x;
}
struct TwoDoubleStruct {
double x, y;
};
double TwoDoubleStruct(struct TwoDoubleStruct d) {
return d.x + d.y;
}
struct TwoDoubleTwoStruct {
struct {
double x, y;
} s;
};
double TwoDoubleTwoStruct(struct TwoDoubleTwoStruct d) {
return d.s.x + d.s.y;
}
struct ThreeDoubleStruct {
double x, y, z;
};
double ThreeDoubleStruct(struct ThreeDoubleStruct d) {
return d.x + d.y + d.z;
}
struct LargeFloatStruct {
double a, b, c, d, e, f;
};
double LargeFloatStruct(struct LargeFloatStruct s) {
return s.a + s.b + s.c + s.d + s.e + s.f;
}
double LargeFloatStructWithRegs(double a, double b, double c, struct LargeFloatStruct s) {
return a + b + c + s.a + s.b + s.c + s.d + s.e + s.f;
}
struct Rect {
double x, y, w, h;
};
double Rectangle(struct Rect rect) {
return rect.x + rect.y + rect.w + rect.h;
}
double RectangleSubtract(struct Rect rect) {
return (rect.x + rect.y) - (rect.w + rect.h);
}
double RectangleWithRegs(double a, double b, double c, double d, double e, struct Rect rect) {
return a + b + c + d + e + rect.x + rect.y + rect.w + rect.h;
}
struct FloatArray {
double a[2];
};
double FloatArray(struct FloatArray f) {
return f.a[0] + f.a[1];
}
struct UnsignedChar4Bytes {
unsigned char a, b, c, d;
};
unsigned int UnsignedChar4Bytes(struct UnsignedChar4Bytes b) {
return (((int)b.a)<<24) | (((int)b.b)<<16) | (((int)b.c)<<8) | (((int)b.d)<<0);
}
struct UnsignedChar4BytesStruct {
struct {
unsigned char a;
} x;
struct {
unsigned char b;
} y;
struct {
unsigned char c;
} z;
struct {
unsigned char d;
} w;
};
unsigned int UnsignedChar4BytesStruct(struct UnsignedChar4BytesStruct b) {
return (((int)b.x.a)<<24) | (((int)b.y.b)<<16) | (((int)b.z.c)<<8) | (((int)b.w.d)<<0);
}
struct Short {
unsigned short a, b, c, d;
};
unsigned long Short(struct Short s) {
return (long)s.a << 48 | (long)s.b << 32 | (long)s.c << 16 | (long)s.d << 0;
}
struct Int {
unsigned int a, b;
};
unsigned long Int(struct Int i) {
return (long)i.a << 32 | (long)i.b << 0;
}
struct Long {
unsigned long a;
};
unsigned long Long(struct Long l) {
return l.a;
}
struct Char8Bytes {
signed char a, b, c, d, e, f, g, h;
};
int Char8Bytes(struct Char8Bytes b) {
return (int)b.a + (int)b.b + (int)b.c + (int)b.d + (int)b.e + (int)b.f + (int)b.g + (int)b.h;
}
struct Odd {
unsigned char a, b, c;
};
int Odd(struct Odd o) {
return (int)o.a + (int)o.b + (int)o.c;
}
struct Char2Short1 {
unsigned char a, b;
unsigned short c;
};
int Char2Short1s(struct Char2Short1 s) {
return (int)s.a + (int)s.b + (int)s.c;
}
struct SignedChar2Short1 {
signed char a, b;
signed short c;
};
int SignedChar2Short1(struct SignedChar2Short1 s) {
return s.a + s.b + s.c;
}
struct Array4UnsignedChars {
unsigned char a[4];
};
unsigned int Array4UnsignedChars(struct Array4UnsignedChars a) {
return (((int)a.a[0])<<24) | (((int)a.a[1])<<16) | (((int)a.a[2])<<8) | (((int)a.a[3])<<0);
}
struct Array3UnsignedChar {
unsigned char a[3];
};
unsigned int Array3UnsignedChars(struct Array3UnsignedChar a) {
return (((int)a.a[0])<<24) | (((int)a.a[1])<<16) | (((int)a.a[2])<<8) | 0xef;
}
struct Array2UnsignedShort {
unsigned short a[2];
};
unsigned int Array2UnsignedShorts(struct Array2UnsignedShort a) {
return (((int)a.a[0])<<16) | (((int)a.a[1])<<0);
}
struct Array4Chars {
signed char a[4];
};
int Array4Chars(struct Array4Chars a) {
return (int)a.a[0] + (int)a.a[1] + (int)a.a[2] + (int)a.a[3];
}
struct Array2Short {
short a[2];
};
int Array2Shorts(struct Array2Short a) {
return (int)a.a[0] + (int)a.a[1];
}
struct Array3Short {
short a[3];
};
int Array3Shorts(struct Array3Short a) {
return (int)a.a[0] + (int)a.a[1] + (int)a.a[2];
}
struct BoolStruct {
_Bool b;
};
_Bool BoolStruct(struct BoolStruct b) {
return b.b;
}
struct BoolFloat {
_Bool b;
float f;
};
float BoolFloat(struct BoolFloat s) {
if (s.b)
return s.f;
return -s.f;
}
struct Content {
struct { double x, y; } point;
struct { double width, height; } size;
};
unsigned long InitWithContentRect(int *win, struct Content c, int style, int backing, _Bool flag) {
if (win == 0)
return 0xBAD;
if (!flag)
return 0xF1A6; // FLAG
return (unsigned long)(c.point.x + c.point.y + c.size.width + c.size.height) / (style - backing);
}
struct GoInt4 {
GoInt a, b, c, d;
};
GoInt GoInt4(struct GoInt4 g) {
return g.a + g.b - g.c + g.d;
}
struct GoUint4 {
GoUint a, b, c, d;
};
GoUint GoUint4(struct GoUint4 g) {
return g.a + g.b + g.c + g.d;
}
GoUint TakeGoUintAndReturn(GoUint a) {
return a;
}
struct FloatAndBool {
float value;
_Bool has_value;
};
int FloatAndBool(struct FloatAndBool f) {
return f.has_value;
}
struct FourInt32s {
int32_t f0;
int32_t f1;
int32_t f2;
int32_t f3;
};
int32_t FourInt32s(struct FourInt32s s) {
return s.f0 + s.f1 + s.f2 + s.f3;
}
struct PointerWrapper {
void* ctx;
};
uintptr_t ExtractPointer(struct PointerWrapper wrapper) {
return (uintptr_t)wrapper.ctx;
}
struct TwoPointers {
void* ptr1;
void* ptr2;
};
uintptr_t AddPointers(struct TwoPointers wrapper) {
return (uintptr_t)wrapper.ptr1 + (uintptr_t)wrapper.ptr2;
}
golang-github-ebitengine-purego-0.10.1/testdata/structtest/structreturn_test.c 0000664 0000000 0000000 00000011402 15207302613 0027747 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
#include
struct Empty{};
struct Empty ReturnEmpty() {
struct Empty e = {};
return e;
}
struct StructInStruct{
struct{ int16_t a; } a;
struct{ int16_t b; } b;
struct{ int16_t c; } c;
};
struct StructInStruct ReturnStructInStruct(int16_t a, int16_t b, int16_t c) {
struct StructInStruct e = {{a}, {b}, {c}};
return e;
}
struct ThreeShorts{
int16_t a, b, c;
};
struct ThreeShorts ReturnThreeShorts(int16_t a, int16_t b, int16_t c) {
struct ThreeShorts e = {a, b, c};
return e;
}
struct FourShorts{
int16_t a, b, c, d;
};
struct FourShorts ReturnFourShorts(int16_t a, int16_t b, int16_t c, int16_t d) {
struct FourShorts e = {a, b, c, d};
return e;
}
struct OneLong{
int64_t a;
};
struct OneLong ReturnOneLong(int64_t a) {
struct OneLong e = {a};
return e;
}
struct TwoLongs{
int64_t a, b;
};
struct TwoLongs ReturnTwoLongs(int64_t a, int64_t b) {
struct TwoLongs e = {a, b};
return e;
}
struct ThreeLongs{
int64_t a, b, c;
};
struct ThreeLongs ReturnThreeLongs(int64_t a, int64_t b, int64_t c) {
struct ThreeLongs e = {a, b, c};
return e;
}
struct OneFloat{
float a;
};
struct TwoFloats{
float a, b;
};
struct TwoFloats ReturnTwoFloats(float a, float b) {
struct TwoFloats e = {a-b, a*b};
return e;
}
struct ThreeFloats{
float a, b, c;
};
struct ThreeFloats ReturnThreeFloats(float a, float b, float c) {
struct ThreeFloats e = {a, b, c};
return e;
}
struct OneFloat ReturnOneFloat(float a) {
struct OneFloat e = {a};
return e;
}
struct OneDouble{
double a;
};
struct OneDouble ReturnOneDouble(double a) {
struct OneDouble e = {a};
return e;
}
struct TwoDoubles{
double a, b;
};
struct TwoDoubles ReturnTwoDoubles(double a, double b) {
struct TwoDoubles e = {a, b};
return e;
}
struct ThreeDoubles{
double a, b, c;
};
struct ThreeDoubles ReturnThreeDoubles(double a, double b, double c) {
struct ThreeDoubles e = {a, b, c};
return e;
}
struct FourDoubles{
double a, b, c, d;
};
struct FourDoubles ReturnFourDoubles(double a, double b, double c, double d) {
struct FourDoubles e = {a, b, c, d};
return e;
}
struct FourDoublesInternal{
struct {
double a, b;
} f;
struct {
double c, d;
} g;
};
struct FourDoublesInternal ReturnFourDoublesInternal(double a, double b, double c, double d) {
struct FourDoublesInternal e = { {a, b}, {c, d} };
return e;
}
struct FiveDoubles{
double a, b, c, d, e;
};
struct FiveDoubles ReturnFiveDoubles(double a, double b, double c, double d, double e) {
struct FiveDoubles s = {a, b, c, d, e};
return s;
}
struct OneFloatOneDouble{
float a;
double b;
};
struct OneFloatOneDouble ReturnOneFloatOneDouble(float a, double b) {
struct OneFloatOneDouble e = {a, b};
return e;
}
struct OneDoubleOneFloat{
double a;
float b;
};
struct OneDoubleOneFloat ReturnOneDoubleOneFloat(double a, float b) {
struct OneDoubleOneFloat e = {a, b};
return e;
}
struct Unaligned1{
int8_t a;
int16_t b;
int64_t c;
};
struct Unaligned1 ReturnUnaligned1(int8_t a, int16_t b, int64_t c) {
struct Unaligned1 e = {a, b, c};
return e;
}
struct Mixed1{
float a;
int32_t b;
};
struct Mixed1 ReturnMixed1(float a, int32_t b) {
struct Mixed1 e = {a, b};
return e;
}
struct Mixed2{
float a;
int32_t b;
float c;
int32_t d;
};
struct Mixed2 ReturnMixed2(float a, int32_t b, float c, int32_t d) {
struct Mixed2 e = {a, b, c, d};
return e;
}
struct Mixed3{
float a;
uint32_t b;
double c;
};
struct Mixed3 ReturnMixed3(float a, uint32_t b, double c) {
struct Mixed3 s = {a, b, c};
return s;
}
struct Mixed4{
double a;
uint32_t b;
float c;
};
struct Mixed4 ReturnMixed4(double a, uint32_t b, float c) {
struct Mixed4 s = {a, b, c};
return s;
}
struct Mixed5{
int64_t *a;
int32_t b;
float c;
int32_t d;
};
struct Mixed5 ReturnMixed5(int64_t *a, int32_t b, float c, int32_t d) {
struct Mixed5 s = {a, b, c, d};
return s;
}
struct Mixed5 IdentityMixed5(struct Mixed5 m) {
return m;
}
struct SmallBool{
_Bool a;
int32_t b;
int64_t c;
};
struct SmallBool ReturnSmallBool(_Bool a, int32_t b, int64_t c) {
struct SmallBool s = {a, b, c};
return s;
}
struct LargeBool{
_Bool a;
int32_t b;
int64_t c;
int64_t d;
};
struct LargeBool ReturnLargeBool(_Bool a, int32_t b, int64_t c, int64_t d) {
struct LargeBool s = {a, b, c, d};
return s;
}
struct Ptr1{
int64_t *a;
void *b;
};
struct Ptr1 ReturnPtr1(int64_t *a, void *b) {
struct Ptr1 s = {a, b};
return s;
}
golang-github-ebitengine-purego-0.10.1/wincallback.go 0000664 0000000 0000000 00000020570 15207302613 0022532 0 ustar 00root root 0000000 0000000 // Copyright 2014 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.
//go:build ignore
// Generate Windows callback assembly file.
// This was copied from the Go repository and modified to generate non-Windows assembly files.
package main
import (
"bytes"
"fmt"
"os"
)
const maxCallback = 2000
func genasm386() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVL and JMP instructions.
// The MOVL instruction loads CX with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from CX and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVL $%d, CX\n", i)
buf.WriteString("\tJMP callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_386.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmAmd64() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// runtime·callbackasm is called by external code to
// execute Go implemented callback function. It is not
// called from the start, instead runtime·compilecallback
// always returns address into runtime·callbackasm offset
// appropriately so different callbacks start with different
// CALL instruction in runtime·callbackasm. This determines
// which Go callback function is executed later on.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
buf.WriteString("\tCALL callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_amd64.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmArm() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVW and B instructions.
// The MOVW instruction loads R12 with the callback index, and the
// B instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVW $%d, R12\n", i)
buf.WriteString("\tB callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_arm.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmArm64() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOV and B instructions.
// The MOV instruction loads R12 with the callback index, and the
// B instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVD $%d, R12\n", i)
buf.WriteString("\tB callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_arm64.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmLoong64() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVV and JMP instructions.
// The MOVV instruction loads R12 with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVV $%d, R12\n", i)
buf.WriteString("\tJMP callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_loong64.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmPpc64le() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVD and BR instructions.
// The MOVD instruction loads R11 with the callback index, and the
// BR instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R11 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVD $%d, R11\n", i)
buf.WriteString("\tBR callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_ppc64le.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmRiscv64() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOV and JMP instructions.
// Since Go 1.26, MOV instructions with immediate values lower than or equal to 32
// are encoded in 2 bytes rather than 4 bytes, which breaks the assumption that each
// callback entry is 8 bytes long. Therefore, for callback indices less than or equal to 32,
// add a PCALIGN directive to align the next instruction to an 8-byte boundary.
// The MOV instruction loads X7 with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from X7 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
space := " "
if i <= 32 {
fmt.Fprintf(&buf, "\tPCALIGN $8\n")
space = " "
}
fmt.Fprintf(&buf, "\tMOV%s$%d, X7\n", space, i)
fmt.Fprintf(&buf, "\tJMP%scallbackasm1(SB)\n", space)
}
if err := os.WriteFile("zcallback_riscv64.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func genasmS390x() {
var buf bytes.Buffer
buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVD and BR instructions.
// The MOVD instruction loads R0 with the callback index, and the
// BR instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R0 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
// NOTE: We use R0 instead of R11 because R11 is callee-saved on S390X.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
`)
for i := 0; i < maxCallback; i++ {
fmt.Fprintf(&buf, "\tMOVD $%d, R0\n", i)
buf.WriteString("\tBR callbackasm1(SB)\n")
}
if err := os.WriteFile("zcallback_s390x.s", buf.Bytes(), 0644); err != nil {
fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
os.Exit(2)
}
}
func main() {
genasm386()
genasmAmd64()
genasmArm()
genasmArm64()
genasmLoong64()
genasmPpc64le()
genasmRiscv64()
genasmS390x()
}
golang-github-ebitengine-purego-0.10.1/zcallback_386.s 0000664 0000000 0000000 00000227252 15207302613 0022451 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVL and JMP instructions.
// The MOVL instruction loads CX with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from CX and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVL $0, CX
JMP callbackasm1(SB)
MOVL $1, CX
JMP callbackasm1(SB)
MOVL $2, CX
JMP callbackasm1(SB)
MOVL $3, CX
JMP callbackasm1(SB)
MOVL $4, CX
JMP callbackasm1(SB)
MOVL $5, CX
JMP callbackasm1(SB)
MOVL $6, CX
JMP callbackasm1(SB)
MOVL $7, CX
JMP callbackasm1(SB)
MOVL $8, CX
JMP callbackasm1(SB)
MOVL $9, CX
JMP callbackasm1(SB)
MOVL $10, CX
JMP callbackasm1(SB)
MOVL $11, CX
JMP callbackasm1(SB)
MOVL $12, CX
JMP callbackasm1(SB)
MOVL $13, CX
JMP callbackasm1(SB)
MOVL $14, CX
JMP callbackasm1(SB)
MOVL $15, CX
JMP callbackasm1(SB)
MOVL $16, CX
JMP callbackasm1(SB)
MOVL $17, CX
JMP callbackasm1(SB)
MOVL $18, CX
JMP callbackasm1(SB)
MOVL $19, CX
JMP callbackasm1(SB)
MOVL $20, CX
JMP callbackasm1(SB)
MOVL $21, CX
JMP callbackasm1(SB)
MOVL $22, CX
JMP callbackasm1(SB)
MOVL $23, CX
JMP callbackasm1(SB)
MOVL $24, CX
JMP callbackasm1(SB)
MOVL $25, CX
JMP callbackasm1(SB)
MOVL $26, CX
JMP callbackasm1(SB)
MOVL $27, CX
JMP callbackasm1(SB)
MOVL $28, CX
JMP callbackasm1(SB)
MOVL $29, CX
JMP callbackasm1(SB)
MOVL $30, CX
JMP callbackasm1(SB)
MOVL $31, CX
JMP callbackasm1(SB)
MOVL $32, CX
JMP callbackasm1(SB)
MOVL $33, CX
JMP callbackasm1(SB)
MOVL $34, CX
JMP callbackasm1(SB)
MOVL $35, CX
JMP callbackasm1(SB)
MOVL $36, CX
JMP callbackasm1(SB)
MOVL $37, CX
JMP callbackasm1(SB)
MOVL $38, CX
JMP callbackasm1(SB)
MOVL $39, CX
JMP callbackasm1(SB)
MOVL $40, CX
JMP callbackasm1(SB)
MOVL $41, CX
JMP callbackasm1(SB)
MOVL $42, CX
JMP callbackasm1(SB)
MOVL $43, CX
JMP callbackasm1(SB)
MOVL $44, CX
JMP callbackasm1(SB)
MOVL $45, CX
JMP callbackasm1(SB)
MOVL $46, CX
JMP callbackasm1(SB)
MOVL $47, CX
JMP callbackasm1(SB)
MOVL $48, CX
JMP callbackasm1(SB)
MOVL $49, CX
JMP callbackasm1(SB)
MOVL $50, CX
JMP callbackasm1(SB)
MOVL $51, CX
JMP callbackasm1(SB)
MOVL $52, CX
JMP callbackasm1(SB)
MOVL $53, CX
JMP callbackasm1(SB)
MOVL $54, CX
JMP callbackasm1(SB)
MOVL $55, CX
JMP callbackasm1(SB)
MOVL $56, CX
JMP callbackasm1(SB)
MOVL $57, CX
JMP callbackasm1(SB)
MOVL $58, CX
JMP callbackasm1(SB)
MOVL $59, CX
JMP callbackasm1(SB)
MOVL $60, CX
JMP callbackasm1(SB)
MOVL $61, CX
JMP callbackasm1(SB)
MOVL $62, CX
JMP callbackasm1(SB)
MOVL $63, CX
JMP callbackasm1(SB)
MOVL $64, CX
JMP callbackasm1(SB)
MOVL $65, CX
JMP callbackasm1(SB)
MOVL $66, CX
JMP callbackasm1(SB)
MOVL $67, CX
JMP callbackasm1(SB)
MOVL $68, CX
JMP callbackasm1(SB)
MOVL $69, CX
JMP callbackasm1(SB)
MOVL $70, CX
JMP callbackasm1(SB)
MOVL $71, CX
JMP callbackasm1(SB)
MOVL $72, CX
JMP callbackasm1(SB)
MOVL $73, CX
JMP callbackasm1(SB)
MOVL $74, CX
JMP callbackasm1(SB)
MOVL $75, CX
JMP callbackasm1(SB)
MOVL $76, CX
JMP callbackasm1(SB)
MOVL $77, CX
JMP callbackasm1(SB)
MOVL $78, CX
JMP callbackasm1(SB)
MOVL $79, CX
JMP callbackasm1(SB)
MOVL $80, CX
JMP callbackasm1(SB)
MOVL $81, CX
JMP callbackasm1(SB)
MOVL $82, CX
JMP callbackasm1(SB)
MOVL $83, CX
JMP callbackasm1(SB)
MOVL $84, CX
JMP callbackasm1(SB)
MOVL $85, CX
JMP callbackasm1(SB)
MOVL $86, CX
JMP callbackasm1(SB)
MOVL $87, CX
JMP callbackasm1(SB)
MOVL $88, CX
JMP callbackasm1(SB)
MOVL $89, CX
JMP callbackasm1(SB)
MOVL $90, CX
JMP callbackasm1(SB)
MOVL $91, CX
JMP callbackasm1(SB)
MOVL $92, CX
JMP callbackasm1(SB)
MOVL $93, CX
JMP callbackasm1(SB)
MOVL $94, CX
JMP callbackasm1(SB)
MOVL $95, CX
JMP callbackasm1(SB)
MOVL $96, CX
JMP callbackasm1(SB)
MOVL $97, CX
JMP callbackasm1(SB)
MOVL $98, CX
JMP callbackasm1(SB)
MOVL $99, CX
JMP callbackasm1(SB)
MOVL $100, CX
JMP callbackasm1(SB)
MOVL $101, CX
JMP callbackasm1(SB)
MOVL $102, CX
JMP callbackasm1(SB)
MOVL $103, CX
JMP callbackasm1(SB)
MOVL $104, CX
JMP callbackasm1(SB)
MOVL $105, CX
JMP callbackasm1(SB)
MOVL $106, CX
JMP callbackasm1(SB)
MOVL $107, CX
JMP callbackasm1(SB)
MOVL $108, CX
JMP callbackasm1(SB)
MOVL $109, CX
JMP callbackasm1(SB)
MOVL $110, CX
JMP callbackasm1(SB)
MOVL $111, CX
JMP callbackasm1(SB)
MOVL $112, CX
JMP callbackasm1(SB)
MOVL $113, CX
JMP callbackasm1(SB)
MOVL $114, CX
JMP callbackasm1(SB)
MOVL $115, CX
JMP callbackasm1(SB)
MOVL $116, CX
JMP callbackasm1(SB)
MOVL $117, CX
JMP callbackasm1(SB)
MOVL $118, CX
JMP callbackasm1(SB)
MOVL $119, CX
JMP callbackasm1(SB)
MOVL $120, CX
JMP callbackasm1(SB)
MOVL $121, CX
JMP callbackasm1(SB)
MOVL $122, CX
JMP callbackasm1(SB)
MOVL $123, CX
JMP callbackasm1(SB)
MOVL $124, CX
JMP callbackasm1(SB)
MOVL $125, CX
JMP callbackasm1(SB)
MOVL $126, CX
JMP callbackasm1(SB)
MOVL $127, CX
JMP callbackasm1(SB)
MOVL $128, CX
JMP callbackasm1(SB)
MOVL $129, CX
JMP callbackasm1(SB)
MOVL $130, CX
JMP callbackasm1(SB)
MOVL $131, CX
JMP callbackasm1(SB)
MOVL $132, CX
JMP callbackasm1(SB)
MOVL $133, CX
JMP callbackasm1(SB)
MOVL $134, CX
JMP callbackasm1(SB)
MOVL $135, CX
JMP callbackasm1(SB)
MOVL $136, CX
JMP callbackasm1(SB)
MOVL $137, CX
JMP callbackasm1(SB)
MOVL $138, CX
JMP callbackasm1(SB)
MOVL $139, CX
JMP callbackasm1(SB)
MOVL $140, CX
JMP callbackasm1(SB)
MOVL $141, CX
JMP callbackasm1(SB)
MOVL $142, CX
JMP callbackasm1(SB)
MOVL $143, CX
JMP callbackasm1(SB)
MOVL $144, CX
JMP callbackasm1(SB)
MOVL $145, CX
JMP callbackasm1(SB)
MOVL $146, CX
JMP callbackasm1(SB)
MOVL $147, CX
JMP callbackasm1(SB)
MOVL $148, CX
JMP callbackasm1(SB)
MOVL $149, CX
JMP callbackasm1(SB)
MOVL $150, CX
JMP callbackasm1(SB)
MOVL $151, CX
JMP callbackasm1(SB)
MOVL $152, CX
JMP callbackasm1(SB)
MOVL $153, CX
JMP callbackasm1(SB)
MOVL $154, CX
JMP callbackasm1(SB)
MOVL $155, CX
JMP callbackasm1(SB)
MOVL $156, CX
JMP callbackasm1(SB)
MOVL $157, CX
JMP callbackasm1(SB)
MOVL $158, CX
JMP callbackasm1(SB)
MOVL $159, CX
JMP callbackasm1(SB)
MOVL $160, CX
JMP callbackasm1(SB)
MOVL $161, CX
JMP callbackasm1(SB)
MOVL $162, CX
JMP callbackasm1(SB)
MOVL $163, CX
JMP callbackasm1(SB)
MOVL $164, CX
JMP callbackasm1(SB)
MOVL $165, CX
JMP callbackasm1(SB)
MOVL $166, CX
JMP callbackasm1(SB)
MOVL $167, CX
JMP callbackasm1(SB)
MOVL $168, CX
JMP callbackasm1(SB)
MOVL $169, CX
JMP callbackasm1(SB)
MOVL $170, CX
JMP callbackasm1(SB)
MOVL $171, CX
JMP callbackasm1(SB)
MOVL $172, CX
JMP callbackasm1(SB)
MOVL $173, CX
JMP callbackasm1(SB)
MOVL $174, CX
JMP callbackasm1(SB)
MOVL $175, CX
JMP callbackasm1(SB)
MOVL $176, CX
JMP callbackasm1(SB)
MOVL $177, CX
JMP callbackasm1(SB)
MOVL $178, CX
JMP callbackasm1(SB)
MOVL $179, CX
JMP callbackasm1(SB)
MOVL $180, CX
JMP callbackasm1(SB)
MOVL $181, CX
JMP callbackasm1(SB)
MOVL $182, CX
JMP callbackasm1(SB)
MOVL $183, CX
JMP callbackasm1(SB)
MOVL $184, CX
JMP callbackasm1(SB)
MOVL $185, CX
JMP callbackasm1(SB)
MOVL $186, CX
JMP callbackasm1(SB)
MOVL $187, CX
JMP callbackasm1(SB)
MOVL $188, CX
JMP callbackasm1(SB)
MOVL $189, CX
JMP callbackasm1(SB)
MOVL $190, CX
JMP callbackasm1(SB)
MOVL $191, CX
JMP callbackasm1(SB)
MOVL $192, CX
JMP callbackasm1(SB)
MOVL $193, CX
JMP callbackasm1(SB)
MOVL $194, CX
JMP callbackasm1(SB)
MOVL $195, CX
JMP callbackasm1(SB)
MOVL $196, CX
JMP callbackasm1(SB)
MOVL $197, CX
JMP callbackasm1(SB)
MOVL $198, CX
JMP callbackasm1(SB)
MOVL $199, CX
JMP callbackasm1(SB)
MOVL $200, CX
JMP callbackasm1(SB)
MOVL $201, CX
JMP callbackasm1(SB)
MOVL $202, CX
JMP callbackasm1(SB)
MOVL $203, CX
JMP callbackasm1(SB)
MOVL $204, CX
JMP callbackasm1(SB)
MOVL $205, CX
JMP callbackasm1(SB)
MOVL $206, CX
JMP callbackasm1(SB)
MOVL $207, CX
JMP callbackasm1(SB)
MOVL $208, CX
JMP callbackasm1(SB)
MOVL $209, CX
JMP callbackasm1(SB)
MOVL $210, CX
JMP callbackasm1(SB)
MOVL $211, CX
JMP callbackasm1(SB)
MOVL $212, CX
JMP callbackasm1(SB)
MOVL $213, CX
JMP callbackasm1(SB)
MOVL $214, CX
JMP callbackasm1(SB)
MOVL $215, CX
JMP callbackasm1(SB)
MOVL $216, CX
JMP callbackasm1(SB)
MOVL $217, CX
JMP callbackasm1(SB)
MOVL $218, CX
JMP callbackasm1(SB)
MOVL $219, CX
JMP callbackasm1(SB)
MOVL $220, CX
JMP callbackasm1(SB)
MOVL $221, CX
JMP callbackasm1(SB)
MOVL $222, CX
JMP callbackasm1(SB)
MOVL $223, CX
JMP callbackasm1(SB)
MOVL $224, CX
JMP callbackasm1(SB)
MOVL $225, CX
JMP callbackasm1(SB)
MOVL $226, CX
JMP callbackasm1(SB)
MOVL $227, CX
JMP callbackasm1(SB)
MOVL $228, CX
JMP callbackasm1(SB)
MOVL $229, CX
JMP callbackasm1(SB)
MOVL $230, CX
JMP callbackasm1(SB)
MOVL $231, CX
JMP callbackasm1(SB)
MOVL $232, CX
JMP callbackasm1(SB)
MOVL $233, CX
JMP callbackasm1(SB)
MOVL $234, CX
JMP callbackasm1(SB)
MOVL $235, CX
JMP callbackasm1(SB)
MOVL $236, CX
JMP callbackasm1(SB)
MOVL $237, CX
JMP callbackasm1(SB)
MOVL $238, CX
JMP callbackasm1(SB)
MOVL $239, CX
JMP callbackasm1(SB)
MOVL $240, CX
JMP callbackasm1(SB)
MOVL $241, CX
JMP callbackasm1(SB)
MOVL $242, CX
JMP callbackasm1(SB)
MOVL $243, CX
JMP callbackasm1(SB)
MOVL $244, CX
JMP callbackasm1(SB)
MOVL $245, CX
JMP callbackasm1(SB)
MOVL $246, CX
JMP callbackasm1(SB)
MOVL $247, CX
JMP callbackasm1(SB)
MOVL $248, CX
JMP callbackasm1(SB)
MOVL $249, CX
JMP callbackasm1(SB)
MOVL $250, CX
JMP callbackasm1(SB)
MOVL $251, CX
JMP callbackasm1(SB)
MOVL $252, CX
JMP callbackasm1(SB)
MOVL $253, CX
JMP callbackasm1(SB)
MOVL $254, CX
JMP callbackasm1(SB)
MOVL $255, CX
JMP callbackasm1(SB)
MOVL $256, CX
JMP callbackasm1(SB)
MOVL $257, CX
JMP callbackasm1(SB)
MOVL $258, CX
JMP callbackasm1(SB)
MOVL $259, CX
JMP callbackasm1(SB)
MOVL $260, CX
JMP callbackasm1(SB)
MOVL $261, CX
JMP callbackasm1(SB)
MOVL $262, CX
JMP callbackasm1(SB)
MOVL $263, CX
JMP callbackasm1(SB)
MOVL $264, CX
JMP callbackasm1(SB)
MOVL $265, CX
JMP callbackasm1(SB)
MOVL $266, CX
JMP callbackasm1(SB)
MOVL $267, CX
JMP callbackasm1(SB)
MOVL $268, CX
JMP callbackasm1(SB)
MOVL $269, CX
JMP callbackasm1(SB)
MOVL $270, CX
JMP callbackasm1(SB)
MOVL $271, CX
JMP callbackasm1(SB)
MOVL $272, CX
JMP callbackasm1(SB)
MOVL $273, CX
JMP callbackasm1(SB)
MOVL $274, CX
JMP callbackasm1(SB)
MOVL $275, CX
JMP callbackasm1(SB)
MOVL $276, CX
JMP callbackasm1(SB)
MOVL $277, CX
JMP callbackasm1(SB)
MOVL $278, CX
JMP callbackasm1(SB)
MOVL $279, CX
JMP callbackasm1(SB)
MOVL $280, CX
JMP callbackasm1(SB)
MOVL $281, CX
JMP callbackasm1(SB)
MOVL $282, CX
JMP callbackasm1(SB)
MOVL $283, CX
JMP callbackasm1(SB)
MOVL $284, CX
JMP callbackasm1(SB)
MOVL $285, CX
JMP callbackasm1(SB)
MOVL $286, CX
JMP callbackasm1(SB)
MOVL $287, CX
JMP callbackasm1(SB)
MOVL $288, CX
JMP callbackasm1(SB)
MOVL $289, CX
JMP callbackasm1(SB)
MOVL $290, CX
JMP callbackasm1(SB)
MOVL $291, CX
JMP callbackasm1(SB)
MOVL $292, CX
JMP callbackasm1(SB)
MOVL $293, CX
JMP callbackasm1(SB)
MOVL $294, CX
JMP callbackasm1(SB)
MOVL $295, CX
JMP callbackasm1(SB)
MOVL $296, CX
JMP callbackasm1(SB)
MOVL $297, CX
JMP callbackasm1(SB)
MOVL $298, CX
JMP callbackasm1(SB)
MOVL $299, CX
JMP callbackasm1(SB)
MOVL $300, CX
JMP callbackasm1(SB)
MOVL $301, CX
JMP callbackasm1(SB)
MOVL $302, CX
JMP callbackasm1(SB)
MOVL $303, CX
JMP callbackasm1(SB)
MOVL $304, CX
JMP callbackasm1(SB)
MOVL $305, CX
JMP callbackasm1(SB)
MOVL $306, CX
JMP callbackasm1(SB)
MOVL $307, CX
JMP callbackasm1(SB)
MOVL $308, CX
JMP callbackasm1(SB)
MOVL $309, CX
JMP callbackasm1(SB)
MOVL $310, CX
JMP callbackasm1(SB)
MOVL $311, CX
JMP callbackasm1(SB)
MOVL $312, CX
JMP callbackasm1(SB)
MOVL $313, CX
JMP callbackasm1(SB)
MOVL $314, CX
JMP callbackasm1(SB)
MOVL $315, CX
JMP callbackasm1(SB)
MOVL $316, CX
JMP callbackasm1(SB)
MOVL $317, CX
JMP callbackasm1(SB)
MOVL $318, CX
JMP callbackasm1(SB)
MOVL $319, CX
JMP callbackasm1(SB)
MOVL $320, CX
JMP callbackasm1(SB)
MOVL $321, CX
JMP callbackasm1(SB)
MOVL $322, CX
JMP callbackasm1(SB)
MOVL $323, CX
JMP callbackasm1(SB)
MOVL $324, CX
JMP callbackasm1(SB)
MOVL $325, CX
JMP callbackasm1(SB)
MOVL $326, CX
JMP callbackasm1(SB)
MOVL $327, CX
JMP callbackasm1(SB)
MOVL $328, CX
JMP callbackasm1(SB)
MOVL $329, CX
JMP callbackasm1(SB)
MOVL $330, CX
JMP callbackasm1(SB)
MOVL $331, CX
JMP callbackasm1(SB)
MOVL $332, CX
JMP callbackasm1(SB)
MOVL $333, CX
JMP callbackasm1(SB)
MOVL $334, CX
JMP callbackasm1(SB)
MOVL $335, CX
JMP callbackasm1(SB)
MOVL $336, CX
JMP callbackasm1(SB)
MOVL $337, CX
JMP callbackasm1(SB)
MOVL $338, CX
JMP callbackasm1(SB)
MOVL $339, CX
JMP callbackasm1(SB)
MOVL $340, CX
JMP callbackasm1(SB)
MOVL $341, CX
JMP callbackasm1(SB)
MOVL $342, CX
JMP callbackasm1(SB)
MOVL $343, CX
JMP callbackasm1(SB)
MOVL $344, CX
JMP callbackasm1(SB)
MOVL $345, CX
JMP callbackasm1(SB)
MOVL $346, CX
JMP callbackasm1(SB)
MOVL $347, CX
JMP callbackasm1(SB)
MOVL $348, CX
JMP callbackasm1(SB)
MOVL $349, CX
JMP callbackasm1(SB)
MOVL $350, CX
JMP callbackasm1(SB)
MOVL $351, CX
JMP callbackasm1(SB)
MOVL $352, CX
JMP callbackasm1(SB)
MOVL $353, CX
JMP callbackasm1(SB)
MOVL $354, CX
JMP callbackasm1(SB)
MOVL $355, CX
JMP callbackasm1(SB)
MOVL $356, CX
JMP callbackasm1(SB)
MOVL $357, CX
JMP callbackasm1(SB)
MOVL $358, CX
JMP callbackasm1(SB)
MOVL $359, CX
JMP callbackasm1(SB)
MOVL $360, CX
JMP callbackasm1(SB)
MOVL $361, CX
JMP callbackasm1(SB)
MOVL $362, CX
JMP callbackasm1(SB)
MOVL $363, CX
JMP callbackasm1(SB)
MOVL $364, CX
JMP callbackasm1(SB)
MOVL $365, CX
JMP callbackasm1(SB)
MOVL $366, CX
JMP callbackasm1(SB)
MOVL $367, CX
JMP callbackasm1(SB)
MOVL $368, CX
JMP callbackasm1(SB)
MOVL $369, CX
JMP callbackasm1(SB)
MOVL $370, CX
JMP callbackasm1(SB)
MOVL $371, CX
JMP callbackasm1(SB)
MOVL $372, CX
JMP callbackasm1(SB)
MOVL $373, CX
JMP callbackasm1(SB)
MOVL $374, CX
JMP callbackasm1(SB)
MOVL $375, CX
JMP callbackasm1(SB)
MOVL $376, CX
JMP callbackasm1(SB)
MOVL $377, CX
JMP callbackasm1(SB)
MOVL $378, CX
JMP callbackasm1(SB)
MOVL $379, CX
JMP callbackasm1(SB)
MOVL $380, CX
JMP callbackasm1(SB)
MOVL $381, CX
JMP callbackasm1(SB)
MOVL $382, CX
JMP callbackasm1(SB)
MOVL $383, CX
JMP callbackasm1(SB)
MOVL $384, CX
JMP callbackasm1(SB)
MOVL $385, CX
JMP callbackasm1(SB)
MOVL $386, CX
JMP callbackasm1(SB)
MOVL $387, CX
JMP callbackasm1(SB)
MOVL $388, CX
JMP callbackasm1(SB)
MOVL $389, CX
JMP callbackasm1(SB)
MOVL $390, CX
JMP callbackasm1(SB)
MOVL $391, CX
JMP callbackasm1(SB)
MOVL $392, CX
JMP callbackasm1(SB)
MOVL $393, CX
JMP callbackasm1(SB)
MOVL $394, CX
JMP callbackasm1(SB)
MOVL $395, CX
JMP callbackasm1(SB)
MOVL $396, CX
JMP callbackasm1(SB)
MOVL $397, CX
JMP callbackasm1(SB)
MOVL $398, CX
JMP callbackasm1(SB)
MOVL $399, CX
JMP callbackasm1(SB)
MOVL $400, CX
JMP callbackasm1(SB)
MOVL $401, CX
JMP callbackasm1(SB)
MOVL $402, CX
JMP callbackasm1(SB)
MOVL $403, CX
JMP callbackasm1(SB)
MOVL $404, CX
JMP callbackasm1(SB)
MOVL $405, CX
JMP callbackasm1(SB)
MOVL $406, CX
JMP callbackasm1(SB)
MOVL $407, CX
JMP callbackasm1(SB)
MOVL $408, CX
JMP callbackasm1(SB)
MOVL $409, CX
JMP callbackasm1(SB)
MOVL $410, CX
JMP callbackasm1(SB)
MOVL $411, CX
JMP callbackasm1(SB)
MOVL $412, CX
JMP callbackasm1(SB)
MOVL $413, CX
JMP callbackasm1(SB)
MOVL $414, CX
JMP callbackasm1(SB)
MOVL $415, CX
JMP callbackasm1(SB)
MOVL $416, CX
JMP callbackasm1(SB)
MOVL $417, CX
JMP callbackasm1(SB)
MOVL $418, CX
JMP callbackasm1(SB)
MOVL $419, CX
JMP callbackasm1(SB)
MOVL $420, CX
JMP callbackasm1(SB)
MOVL $421, CX
JMP callbackasm1(SB)
MOVL $422, CX
JMP callbackasm1(SB)
MOVL $423, CX
JMP callbackasm1(SB)
MOVL $424, CX
JMP callbackasm1(SB)
MOVL $425, CX
JMP callbackasm1(SB)
MOVL $426, CX
JMP callbackasm1(SB)
MOVL $427, CX
JMP callbackasm1(SB)
MOVL $428, CX
JMP callbackasm1(SB)
MOVL $429, CX
JMP callbackasm1(SB)
MOVL $430, CX
JMP callbackasm1(SB)
MOVL $431, CX
JMP callbackasm1(SB)
MOVL $432, CX
JMP callbackasm1(SB)
MOVL $433, CX
JMP callbackasm1(SB)
MOVL $434, CX
JMP callbackasm1(SB)
MOVL $435, CX
JMP callbackasm1(SB)
MOVL $436, CX
JMP callbackasm1(SB)
MOVL $437, CX
JMP callbackasm1(SB)
MOVL $438, CX
JMP callbackasm1(SB)
MOVL $439, CX
JMP callbackasm1(SB)
MOVL $440, CX
JMP callbackasm1(SB)
MOVL $441, CX
JMP callbackasm1(SB)
MOVL $442, CX
JMP callbackasm1(SB)
MOVL $443, CX
JMP callbackasm1(SB)
MOVL $444, CX
JMP callbackasm1(SB)
MOVL $445, CX
JMP callbackasm1(SB)
MOVL $446, CX
JMP callbackasm1(SB)
MOVL $447, CX
JMP callbackasm1(SB)
MOVL $448, CX
JMP callbackasm1(SB)
MOVL $449, CX
JMP callbackasm1(SB)
MOVL $450, CX
JMP callbackasm1(SB)
MOVL $451, CX
JMP callbackasm1(SB)
MOVL $452, CX
JMP callbackasm1(SB)
MOVL $453, CX
JMP callbackasm1(SB)
MOVL $454, CX
JMP callbackasm1(SB)
MOVL $455, CX
JMP callbackasm1(SB)
MOVL $456, CX
JMP callbackasm1(SB)
MOVL $457, CX
JMP callbackasm1(SB)
MOVL $458, CX
JMP callbackasm1(SB)
MOVL $459, CX
JMP callbackasm1(SB)
MOVL $460, CX
JMP callbackasm1(SB)
MOVL $461, CX
JMP callbackasm1(SB)
MOVL $462, CX
JMP callbackasm1(SB)
MOVL $463, CX
JMP callbackasm1(SB)
MOVL $464, CX
JMP callbackasm1(SB)
MOVL $465, CX
JMP callbackasm1(SB)
MOVL $466, CX
JMP callbackasm1(SB)
MOVL $467, CX
JMP callbackasm1(SB)
MOVL $468, CX
JMP callbackasm1(SB)
MOVL $469, CX
JMP callbackasm1(SB)
MOVL $470, CX
JMP callbackasm1(SB)
MOVL $471, CX
JMP callbackasm1(SB)
MOVL $472, CX
JMP callbackasm1(SB)
MOVL $473, CX
JMP callbackasm1(SB)
MOVL $474, CX
JMP callbackasm1(SB)
MOVL $475, CX
JMP callbackasm1(SB)
MOVL $476, CX
JMP callbackasm1(SB)
MOVL $477, CX
JMP callbackasm1(SB)
MOVL $478, CX
JMP callbackasm1(SB)
MOVL $479, CX
JMP callbackasm1(SB)
MOVL $480, CX
JMP callbackasm1(SB)
MOVL $481, CX
JMP callbackasm1(SB)
MOVL $482, CX
JMP callbackasm1(SB)
MOVL $483, CX
JMP callbackasm1(SB)
MOVL $484, CX
JMP callbackasm1(SB)
MOVL $485, CX
JMP callbackasm1(SB)
MOVL $486, CX
JMP callbackasm1(SB)
MOVL $487, CX
JMP callbackasm1(SB)
MOVL $488, CX
JMP callbackasm1(SB)
MOVL $489, CX
JMP callbackasm1(SB)
MOVL $490, CX
JMP callbackasm1(SB)
MOVL $491, CX
JMP callbackasm1(SB)
MOVL $492, CX
JMP callbackasm1(SB)
MOVL $493, CX
JMP callbackasm1(SB)
MOVL $494, CX
JMP callbackasm1(SB)
MOVL $495, CX
JMP callbackasm1(SB)
MOVL $496, CX
JMP callbackasm1(SB)
MOVL $497, CX
JMP callbackasm1(SB)
MOVL $498, CX
JMP callbackasm1(SB)
MOVL $499, CX
JMP callbackasm1(SB)
MOVL $500, CX
JMP callbackasm1(SB)
MOVL $501, CX
JMP callbackasm1(SB)
MOVL $502, CX
JMP callbackasm1(SB)
MOVL $503, CX
JMP callbackasm1(SB)
MOVL $504, CX
JMP callbackasm1(SB)
MOVL $505, CX
JMP callbackasm1(SB)
MOVL $506, CX
JMP callbackasm1(SB)
MOVL $507, CX
JMP callbackasm1(SB)
MOVL $508, CX
JMP callbackasm1(SB)
MOVL $509, CX
JMP callbackasm1(SB)
MOVL $510, CX
JMP callbackasm1(SB)
MOVL $511, CX
JMP callbackasm1(SB)
MOVL $512, CX
JMP callbackasm1(SB)
MOVL $513, CX
JMP callbackasm1(SB)
MOVL $514, CX
JMP callbackasm1(SB)
MOVL $515, CX
JMP callbackasm1(SB)
MOVL $516, CX
JMP callbackasm1(SB)
MOVL $517, CX
JMP callbackasm1(SB)
MOVL $518, CX
JMP callbackasm1(SB)
MOVL $519, CX
JMP callbackasm1(SB)
MOVL $520, CX
JMP callbackasm1(SB)
MOVL $521, CX
JMP callbackasm1(SB)
MOVL $522, CX
JMP callbackasm1(SB)
MOVL $523, CX
JMP callbackasm1(SB)
MOVL $524, CX
JMP callbackasm1(SB)
MOVL $525, CX
JMP callbackasm1(SB)
MOVL $526, CX
JMP callbackasm1(SB)
MOVL $527, CX
JMP callbackasm1(SB)
MOVL $528, CX
JMP callbackasm1(SB)
MOVL $529, CX
JMP callbackasm1(SB)
MOVL $530, CX
JMP callbackasm1(SB)
MOVL $531, CX
JMP callbackasm1(SB)
MOVL $532, CX
JMP callbackasm1(SB)
MOVL $533, CX
JMP callbackasm1(SB)
MOVL $534, CX
JMP callbackasm1(SB)
MOVL $535, CX
JMP callbackasm1(SB)
MOVL $536, CX
JMP callbackasm1(SB)
MOVL $537, CX
JMP callbackasm1(SB)
MOVL $538, CX
JMP callbackasm1(SB)
MOVL $539, CX
JMP callbackasm1(SB)
MOVL $540, CX
JMP callbackasm1(SB)
MOVL $541, CX
JMP callbackasm1(SB)
MOVL $542, CX
JMP callbackasm1(SB)
MOVL $543, CX
JMP callbackasm1(SB)
MOVL $544, CX
JMP callbackasm1(SB)
MOVL $545, CX
JMP callbackasm1(SB)
MOVL $546, CX
JMP callbackasm1(SB)
MOVL $547, CX
JMP callbackasm1(SB)
MOVL $548, CX
JMP callbackasm1(SB)
MOVL $549, CX
JMP callbackasm1(SB)
MOVL $550, CX
JMP callbackasm1(SB)
MOVL $551, CX
JMP callbackasm1(SB)
MOVL $552, CX
JMP callbackasm1(SB)
MOVL $553, CX
JMP callbackasm1(SB)
MOVL $554, CX
JMP callbackasm1(SB)
MOVL $555, CX
JMP callbackasm1(SB)
MOVL $556, CX
JMP callbackasm1(SB)
MOVL $557, CX
JMP callbackasm1(SB)
MOVL $558, CX
JMP callbackasm1(SB)
MOVL $559, CX
JMP callbackasm1(SB)
MOVL $560, CX
JMP callbackasm1(SB)
MOVL $561, CX
JMP callbackasm1(SB)
MOVL $562, CX
JMP callbackasm1(SB)
MOVL $563, CX
JMP callbackasm1(SB)
MOVL $564, CX
JMP callbackasm1(SB)
MOVL $565, CX
JMP callbackasm1(SB)
MOVL $566, CX
JMP callbackasm1(SB)
MOVL $567, CX
JMP callbackasm1(SB)
MOVL $568, CX
JMP callbackasm1(SB)
MOVL $569, CX
JMP callbackasm1(SB)
MOVL $570, CX
JMP callbackasm1(SB)
MOVL $571, CX
JMP callbackasm1(SB)
MOVL $572, CX
JMP callbackasm1(SB)
MOVL $573, CX
JMP callbackasm1(SB)
MOVL $574, CX
JMP callbackasm1(SB)
MOVL $575, CX
JMP callbackasm1(SB)
MOVL $576, CX
JMP callbackasm1(SB)
MOVL $577, CX
JMP callbackasm1(SB)
MOVL $578, CX
JMP callbackasm1(SB)
MOVL $579, CX
JMP callbackasm1(SB)
MOVL $580, CX
JMP callbackasm1(SB)
MOVL $581, CX
JMP callbackasm1(SB)
MOVL $582, CX
JMP callbackasm1(SB)
MOVL $583, CX
JMP callbackasm1(SB)
MOVL $584, CX
JMP callbackasm1(SB)
MOVL $585, CX
JMP callbackasm1(SB)
MOVL $586, CX
JMP callbackasm1(SB)
MOVL $587, CX
JMP callbackasm1(SB)
MOVL $588, CX
JMP callbackasm1(SB)
MOVL $589, CX
JMP callbackasm1(SB)
MOVL $590, CX
JMP callbackasm1(SB)
MOVL $591, CX
JMP callbackasm1(SB)
MOVL $592, CX
JMP callbackasm1(SB)
MOVL $593, CX
JMP callbackasm1(SB)
MOVL $594, CX
JMP callbackasm1(SB)
MOVL $595, CX
JMP callbackasm1(SB)
MOVL $596, CX
JMP callbackasm1(SB)
MOVL $597, CX
JMP callbackasm1(SB)
MOVL $598, CX
JMP callbackasm1(SB)
MOVL $599, CX
JMP callbackasm1(SB)
MOVL $600, CX
JMP callbackasm1(SB)
MOVL $601, CX
JMP callbackasm1(SB)
MOVL $602, CX
JMP callbackasm1(SB)
MOVL $603, CX
JMP callbackasm1(SB)
MOVL $604, CX
JMP callbackasm1(SB)
MOVL $605, CX
JMP callbackasm1(SB)
MOVL $606, CX
JMP callbackasm1(SB)
MOVL $607, CX
JMP callbackasm1(SB)
MOVL $608, CX
JMP callbackasm1(SB)
MOVL $609, CX
JMP callbackasm1(SB)
MOVL $610, CX
JMP callbackasm1(SB)
MOVL $611, CX
JMP callbackasm1(SB)
MOVL $612, CX
JMP callbackasm1(SB)
MOVL $613, CX
JMP callbackasm1(SB)
MOVL $614, CX
JMP callbackasm1(SB)
MOVL $615, CX
JMP callbackasm1(SB)
MOVL $616, CX
JMP callbackasm1(SB)
MOVL $617, CX
JMP callbackasm1(SB)
MOVL $618, CX
JMP callbackasm1(SB)
MOVL $619, CX
JMP callbackasm1(SB)
MOVL $620, CX
JMP callbackasm1(SB)
MOVL $621, CX
JMP callbackasm1(SB)
MOVL $622, CX
JMP callbackasm1(SB)
MOVL $623, CX
JMP callbackasm1(SB)
MOVL $624, CX
JMP callbackasm1(SB)
MOVL $625, CX
JMP callbackasm1(SB)
MOVL $626, CX
JMP callbackasm1(SB)
MOVL $627, CX
JMP callbackasm1(SB)
MOVL $628, CX
JMP callbackasm1(SB)
MOVL $629, CX
JMP callbackasm1(SB)
MOVL $630, CX
JMP callbackasm1(SB)
MOVL $631, CX
JMP callbackasm1(SB)
MOVL $632, CX
JMP callbackasm1(SB)
MOVL $633, CX
JMP callbackasm1(SB)
MOVL $634, CX
JMP callbackasm1(SB)
MOVL $635, CX
JMP callbackasm1(SB)
MOVL $636, CX
JMP callbackasm1(SB)
MOVL $637, CX
JMP callbackasm1(SB)
MOVL $638, CX
JMP callbackasm1(SB)
MOVL $639, CX
JMP callbackasm1(SB)
MOVL $640, CX
JMP callbackasm1(SB)
MOVL $641, CX
JMP callbackasm1(SB)
MOVL $642, CX
JMP callbackasm1(SB)
MOVL $643, CX
JMP callbackasm1(SB)
MOVL $644, CX
JMP callbackasm1(SB)
MOVL $645, CX
JMP callbackasm1(SB)
MOVL $646, CX
JMP callbackasm1(SB)
MOVL $647, CX
JMP callbackasm1(SB)
MOVL $648, CX
JMP callbackasm1(SB)
MOVL $649, CX
JMP callbackasm1(SB)
MOVL $650, CX
JMP callbackasm1(SB)
MOVL $651, CX
JMP callbackasm1(SB)
MOVL $652, CX
JMP callbackasm1(SB)
MOVL $653, CX
JMP callbackasm1(SB)
MOVL $654, CX
JMP callbackasm1(SB)
MOVL $655, CX
JMP callbackasm1(SB)
MOVL $656, CX
JMP callbackasm1(SB)
MOVL $657, CX
JMP callbackasm1(SB)
MOVL $658, CX
JMP callbackasm1(SB)
MOVL $659, CX
JMP callbackasm1(SB)
MOVL $660, CX
JMP callbackasm1(SB)
MOVL $661, CX
JMP callbackasm1(SB)
MOVL $662, CX
JMP callbackasm1(SB)
MOVL $663, CX
JMP callbackasm1(SB)
MOVL $664, CX
JMP callbackasm1(SB)
MOVL $665, CX
JMP callbackasm1(SB)
MOVL $666, CX
JMP callbackasm1(SB)
MOVL $667, CX
JMP callbackasm1(SB)
MOVL $668, CX
JMP callbackasm1(SB)
MOVL $669, CX
JMP callbackasm1(SB)
MOVL $670, CX
JMP callbackasm1(SB)
MOVL $671, CX
JMP callbackasm1(SB)
MOVL $672, CX
JMP callbackasm1(SB)
MOVL $673, CX
JMP callbackasm1(SB)
MOVL $674, CX
JMP callbackasm1(SB)
MOVL $675, CX
JMP callbackasm1(SB)
MOVL $676, CX
JMP callbackasm1(SB)
MOVL $677, CX
JMP callbackasm1(SB)
MOVL $678, CX
JMP callbackasm1(SB)
MOVL $679, CX
JMP callbackasm1(SB)
MOVL $680, CX
JMP callbackasm1(SB)
MOVL $681, CX
JMP callbackasm1(SB)
MOVL $682, CX
JMP callbackasm1(SB)
MOVL $683, CX
JMP callbackasm1(SB)
MOVL $684, CX
JMP callbackasm1(SB)
MOVL $685, CX
JMP callbackasm1(SB)
MOVL $686, CX
JMP callbackasm1(SB)
MOVL $687, CX
JMP callbackasm1(SB)
MOVL $688, CX
JMP callbackasm1(SB)
MOVL $689, CX
JMP callbackasm1(SB)
MOVL $690, CX
JMP callbackasm1(SB)
MOVL $691, CX
JMP callbackasm1(SB)
MOVL $692, CX
JMP callbackasm1(SB)
MOVL $693, CX
JMP callbackasm1(SB)
MOVL $694, CX
JMP callbackasm1(SB)
MOVL $695, CX
JMP callbackasm1(SB)
MOVL $696, CX
JMP callbackasm1(SB)
MOVL $697, CX
JMP callbackasm1(SB)
MOVL $698, CX
JMP callbackasm1(SB)
MOVL $699, CX
JMP callbackasm1(SB)
MOVL $700, CX
JMP callbackasm1(SB)
MOVL $701, CX
JMP callbackasm1(SB)
MOVL $702, CX
JMP callbackasm1(SB)
MOVL $703, CX
JMP callbackasm1(SB)
MOVL $704, CX
JMP callbackasm1(SB)
MOVL $705, CX
JMP callbackasm1(SB)
MOVL $706, CX
JMP callbackasm1(SB)
MOVL $707, CX
JMP callbackasm1(SB)
MOVL $708, CX
JMP callbackasm1(SB)
MOVL $709, CX
JMP callbackasm1(SB)
MOVL $710, CX
JMP callbackasm1(SB)
MOVL $711, CX
JMP callbackasm1(SB)
MOVL $712, CX
JMP callbackasm1(SB)
MOVL $713, CX
JMP callbackasm1(SB)
MOVL $714, CX
JMP callbackasm1(SB)
MOVL $715, CX
JMP callbackasm1(SB)
MOVL $716, CX
JMP callbackasm1(SB)
MOVL $717, CX
JMP callbackasm1(SB)
MOVL $718, CX
JMP callbackasm1(SB)
MOVL $719, CX
JMP callbackasm1(SB)
MOVL $720, CX
JMP callbackasm1(SB)
MOVL $721, CX
JMP callbackasm1(SB)
MOVL $722, CX
JMP callbackasm1(SB)
MOVL $723, CX
JMP callbackasm1(SB)
MOVL $724, CX
JMP callbackasm1(SB)
MOVL $725, CX
JMP callbackasm1(SB)
MOVL $726, CX
JMP callbackasm1(SB)
MOVL $727, CX
JMP callbackasm1(SB)
MOVL $728, CX
JMP callbackasm1(SB)
MOVL $729, CX
JMP callbackasm1(SB)
MOVL $730, CX
JMP callbackasm1(SB)
MOVL $731, CX
JMP callbackasm1(SB)
MOVL $732, CX
JMP callbackasm1(SB)
MOVL $733, CX
JMP callbackasm1(SB)
MOVL $734, CX
JMP callbackasm1(SB)
MOVL $735, CX
JMP callbackasm1(SB)
MOVL $736, CX
JMP callbackasm1(SB)
MOVL $737, CX
JMP callbackasm1(SB)
MOVL $738, CX
JMP callbackasm1(SB)
MOVL $739, CX
JMP callbackasm1(SB)
MOVL $740, CX
JMP callbackasm1(SB)
MOVL $741, CX
JMP callbackasm1(SB)
MOVL $742, CX
JMP callbackasm1(SB)
MOVL $743, CX
JMP callbackasm1(SB)
MOVL $744, CX
JMP callbackasm1(SB)
MOVL $745, CX
JMP callbackasm1(SB)
MOVL $746, CX
JMP callbackasm1(SB)
MOVL $747, CX
JMP callbackasm1(SB)
MOVL $748, CX
JMP callbackasm1(SB)
MOVL $749, CX
JMP callbackasm1(SB)
MOVL $750, CX
JMP callbackasm1(SB)
MOVL $751, CX
JMP callbackasm1(SB)
MOVL $752, CX
JMP callbackasm1(SB)
MOVL $753, CX
JMP callbackasm1(SB)
MOVL $754, CX
JMP callbackasm1(SB)
MOVL $755, CX
JMP callbackasm1(SB)
MOVL $756, CX
JMP callbackasm1(SB)
MOVL $757, CX
JMP callbackasm1(SB)
MOVL $758, CX
JMP callbackasm1(SB)
MOVL $759, CX
JMP callbackasm1(SB)
MOVL $760, CX
JMP callbackasm1(SB)
MOVL $761, CX
JMP callbackasm1(SB)
MOVL $762, CX
JMP callbackasm1(SB)
MOVL $763, CX
JMP callbackasm1(SB)
MOVL $764, CX
JMP callbackasm1(SB)
MOVL $765, CX
JMP callbackasm1(SB)
MOVL $766, CX
JMP callbackasm1(SB)
MOVL $767, CX
JMP callbackasm1(SB)
MOVL $768, CX
JMP callbackasm1(SB)
MOVL $769, CX
JMP callbackasm1(SB)
MOVL $770, CX
JMP callbackasm1(SB)
MOVL $771, CX
JMP callbackasm1(SB)
MOVL $772, CX
JMP callbackasm1(SB)
MOVL $773, CX
JMP callbackasm1(SB)
MOVL $774, CX
JMP callbackasm1(SB)
MOVL $775, CX
JMP callbackasm1(SB)
MOVL $776, CX
JMP callbackasm1(SB)
MOVL $777, CX
JMP callbackasm1(SB)
MOVL $778, CX
JMP callbackasm1(SB)
MOVL $779, CX
JMP callbackasm1(SB)
MOVL $780, CX
JMP callbackasm1(SB)
MOVL $781, CX
JMP callbackasm1(SB)
MOVL $782, CX
JMP callbackasm1(SB)
MOVL $783, CX
JMP callbackasm1(SB)
MOVL $784, CX
JMP callbackasm1(SB)
MOVL $785, CX
JMP callbackasm1(SB)
MOVL $786, CX
JMP callbackasm1(SB)
MOVL $787, CX
JMP callbackasm1(SB)
MOVL $788, CX
JMP callbackasm1(SB)
MOVL $789, CX
JMP callbackasm1(SB)
MOVL $790, CX
JMP callbackasm1(SB)
MOVL $791, CX
JMP callbackasm1(SB)
MOVL $792, CX
JMP callbackasm1(SB)
MOVL $793, CX
JMP callbackasm1(SB)
MOVL $794, CX
JMP callbackasm1(SB)
MOVL $795, CX
JMP callbackasm1(SB)
MOVL $796, CX
JMP callbackasm1(SB)
MOVL $797, CX
JMP callbackasm1(SB)
MOVL $798, CX
JMP callbackasm1(SB)
MOVL $799, CX
JMP callbackasm1(SB)
MOVL $800, CX
JMP callbackasm1(SB)
MOVL $801, CX
JMP callbackasm1(SB)
MOVL $802, CX
JMP callbackasm1(SB)
MOVL $803, CX
JMP callbackasm1(SB)
MOVL $804, CX
JMP callbackasm1(SB)
MOVL $805, CX
JMP callbackasm1(SB)
MOVL $806, CX
JMP callbackasm1(SB)
MOVL $807, CX
JMP callbackasm1(SB)
MOVL $808, CX
JMP callbackasm1(SB)
MOVL $809, CX
JMP callbackasm1(SB)
MOVL $810, CX
JMP callbackasm1(SB)
MOVL $811, CX
JMP callbackasm1(SB)
MOVL $812, CX
JMP callbackasm1(SB)
MOVL $813, CX
JMP callbackasm1(SB)
MOVL $814, CX
JMP callbackasm1(SB)
MOVL $815, CX
JMP callbackasm1(SB)
MOVL $816, CX
JMP callbackasm1(SB)
MOVL $817, CX
JMP callbackasm1(SB)
MOVL $818, CX
JMP callbackasm1(SB)
MOVL $819, CX
JMP callbackasm1(SB)
MOVL $820, CX
JMP callbackasm1(SB)
MOVL $821, CX
JMP callbackasm1(SB)
MOVL $822, CX
JMP callbackasm1(SB)
MOVL $823, CX
JMP callbackasm1(SB)
MOVL $824, CX
JMP callbackasm1(SB)
MOVL $825, CX
JMP callbackasm1(SB)
MOVL $826, CX
JMP callbackasm1(SB)
MOVL $827, CX
JMP callbackasm1(SB)
MOVL $828, CX
JMP callbackasm1(SB)
MOVL $829, CX
JMP callbackasm1(SB)
MOVL $830, CX
JMP callbackasm1(SB)
MOVL $831, CX
JMP callbackasm1(SB)
MOVL $832, CX
JMP callbackasm1(SB)
MOVL $833, CX
JMP callbackasm1(SB)
MOVL $834, CX
JMP callbackasm1(SB)
MOVL $835, CX
JMP callbackasm1(SB)
MOVL $836, CX
JMP callbackasm1(SB)
MOVL $837, CX
JMP callbackasm1(SB)
MOVL $838, CX
JMP callbackasm1(SB)
MOVL $839, CX
JMP callbackasm1(SB)
MOVL $840, CX
JMP callbackasm1(SB)
MOVL $841, CX
JMP callbackasm1(SB)
MOVL $842, CX
JMP callbackasm1(SB)
MOVL $843, CX
JMP callbackasm1(SB)
MOVL $844, CX
JMP callbackasm1(SB)
MOVL $845, CX
JMP callbackasm1(SB)
MOVL $846, CX
JMP callbackasm1(SB)
MOVL $847, CX
JMP callbackasm1(SB)
MOVL $848, CX
JMP callbackasm1(SB)
MOVL $849, CX
JMP callbackasm1(SB)
MOVL $850, CX
JMP callbackasm1(SB)
MOVL $851, CX
JMP callbackasm1(SB)
MOVL $852, CX
JMP callbackasm1(SB)
MOVL $853, CX
JMP callbackasm1(SB)
MOVL $854, CX
JMP callbackasm1(SB)
MOVL $855, CX
JMP callbackasm1(SB)
MOVL $856, CX
JMP callbackasm1(SB)
MOVL $857, CX
JMP callbackasm1(SB)
MOVL $858, CX
JMP callbackasm1(SB)
MOVL $859, CX
JMP callbackasm1(SB)
MOVL $860, CX
JMP callbackasm1(SB)
MOVL $861, CX
JMP callbackasm1(SB)
MOVL $862, CX
JMP callbackasm1(SB)
MOVL $863, CX
JMP callbackasm1(SB)
MOVL $864, CX
JMP callbackasm1(SB)
MOVL $865, CX
JMP callbackasm1(SB)
MOVL $866, CX
JMP callbackasm1(SB)
MOVL $867, CX
JMP callbackasm1(SB)
MOVL $868, CX
JMP callbackasm1(SB)
MOVL $869, CX
JMP callbackasm1(SB)
MOVL $870, CX
JMP callbackasm1(SB)
MOVL $871, CX
JMP callbackasm1(SB)
MOVL $872, CX
JMP callbackasm1(SB)
MOVL $873, CX
JMP callbackasm1(SB)
MOVL $874, CX
JMP callbackasm1(SB)
MOVL $875, CX
JMP callbackasm1(SB)
MOVL $876, CX
JMP callbackasm1(SB)
MOVL $877, CX
JMP callbackasm1(SB)
MOVL $878, CX
JMP callbackasm1(SB)
MOVL $879, CX
JMP callbackasm1(SB)
MOVL $880, CX
JMP callbackasm1(SB)
MOVL $881, CX
JMP callbackasm1(SB)
MOVL $882, CX
JMP callbackasm1(SB)
MOVL $883, CX
JMP callbackasm1(SB)
MOVL $884, CX
JMP callbackasm1(SB)
MOVL $885, CX
JMP callbackasm1(SB)
MOVL $886, CX
JMP callbackasm1(SB)
MOVL $887, CX
JMP callbackasm1(SB)
MOVL $888, CX
JMP callbackasm1(SB)
MOVL $889, CX
JMP callbackasm1(SB)
MOVL $890, CX
JMP callbackasm1(SB)
MOVL $891, CX
JMP callbackasm1(SB)
MOVL $892, CX
JMP callbackasm1(SB)
MOVL $893, CX
JMP callbackasm1(SB)
MOVL $894, CX
JMP callbackasm1(SB)
MOVL $895, CX
JMP callbackasm1(SB)
MOVL $896, CX
JMP callbackasm1(SB)
MOVL $897, CX
JMP callbackasm1(SB)
MOVL $898, CX
JMP callbackasm1(SB)
MOVL $899, CX
JMP callbackasm1(SB)
MOVL $900, CX
JMP callbackasm1(SB)
MOVL $901, CX
JMP callbackasm1(SB)
MOVL $902, CX
JMP callbackasm1(SB)
MOVL $903, CX
JMP callbackasm1(SB)
MOVL $904, CX
JMP callbackasm1(SB)
MOVL $905, CX
JMP callbackasm1(SB)
MOVL $906, CX
JMP callbackasm1(SB)
MOVL $907, CX
JMP callbackasm1(SB)
MOVL $908, CX
JMP callbackasm1(SB)
MOVL $909, CX
JMP callbackasm1(SB)
MOVL $910, CX
JMP callbackasm1(SB)
MOVL $911, CX
JMP callbackasm1(SB)
MOVL $912, CX
JMP callbackasm1(SB)
MOVL $913, CX
JMP callbackasm1(SB)
MOVL $914, CX
JMP callbackasm1(SB)
MOVL $915, CX
JMP callbackasm1(SB)
MOVL $916, CX
JMP callbackasm1(SB)
MOVL $917, CX
JMP callbackasm1(SB)
MOVL $918, CX
JMP callbackasm1(SB)
MOVL $919, CX
JMP callbackasm1(SB)
MOVL $920, CX
JMP callbackasm1(SB)
MOVL $921, CX
JMP callbackasm1(SB)
MOVL $922, CX
JMP callbackasm1(SB)
MOVL $923, CX
JMP callbackasm1(SB)
MOVL $924, CX
JMP callbackasm1(SB)
MOVL $925, CX
JMP callbackasm1(SB)
MOVL $926, CX
JMP callbackasm1(SB)
MOVL $927, CX
JMP callbackasm1(SB)
MOVL $928, CX
JMP callbackasm1(SB)
MOVL $929, CX
JMP callbackasm1(SB)
MOVL $930, CX
JMP callbackasm1(SB)
MOVL $931, CX
JMP callbackasm1(SB)
MOVL $932, CX
JMP callbackasm1(SB)
MOVL $933, CX
JMP callbackasm1(SB)
MOVL $934, CX
JMP callbackasm1(SB)
MOVL $935, CX
JMP callbackasm1(SB)
MOVL $936, CX
JMP callbackasm1(SB)
MOVL $937, CX
JMP callbackasm1(SB)
MOVL $938, CX
JMP callbackasm1(SB)
MOVL $939, CX
JMP callbackasm1(SB)
MOVL $940, CX
JMP callbackasm1(SB)
MOVL $941, CX
JMP callbackasm1(SB)
MOVL $942, CX
JMP callbackasm1(SB)
MOVL $943, CX
JMP callbackasm1(SB)
MOVL $944, CX
JMP callbackasm1(SB)
MOVL $945, CX
JMP callbackasm1(SB)
MOVL $946, CX
JMP callbackasm1(SB)
MOVL $947, CX
JMP callbackasm1(SB)
MOVL $948, CX
JMP callbackasm1(SB)
MOVL $949, CX
JMP callbackasm1(SB)
MOVL $950, CX
JMP callbackasm1(SB)
MOVL $951, CX
JMP callbackasm1(SB)
MOVL $952, CX
JMP callbackasm1(SB)
MOVL $953, CX
JMP callbackasm1(SB)
MOVL $954, CX
JMP callbackasm1(SB)
MOVL $955, CX
JMP callbackasm1(SB)
MOVL $956, CX
JMP callbackasm1(SB)
MOVL $957, CX
JMP callbackasm1(SB)
MOVL $958, CX
JMP callbackasm1(SB)
MOVL $959, CX
JMP callbackasm1(SB)
MOVL $960, CX
JMP callbackasm1(SB)
MOVL $961, CX
JMP callbackasm1(SB)
MOVL $962, CX
JMP callbackasm1(SB)
MOVL $963, CX
JMP callbackasm1(SB)
MOVL $964, CX
JMP callbackasm1(SB)
MOVL $965, CX
JMP callbackasm1(SB)
MOVL $966, CX
JMP callbackasm1(SB)
MOVL $967, CX
JMP callbackasm1(SB)
MOVL $968, CX
JMP callbackasm1(SB)
MOVL $969, CX
JMP callbackasm1(SB)
MOVL $970, CX
JMP callbackasm1(SB)
MOVL $971, CX
JMP callbackasm1(SB)
MOVL $972, CX
JMP callbackasm1(SB)
MOVL $973, CX
JMP callbackasm1(SB)
MOVL $974, CX
JMP callbackasm1(SB)
MOVL $975, CX
JMP callbackasm1(SB)
MOVL $976, CX
JMP callbackasm1(SB)
MOVL $977, CX
JMP callbackasm1(SB)
MOVL $978, CX
JMP callbackasm1(SB)
MOVL $979, CX
JMP callbackasm1(SB)
MOVL $980, CX
JMP callbackasm1(SB)
MOVL $981, CX
JMP callbackasm1(SB)
MOVL $982, CX
JMP callbackasm1(SB)
MOVL $983, CX
JMP callbackasm1(SB)
MOVL $984, CX
JMP callbackasm1(SB)
MOVL $985, CX
JMP callbackasm1(SB)
MOVL $986, CX
JMP callbackasm1(SB)
MOVL $987, CX
JMP callbackasm1(SB)
MOVL $988, CX
JMP callbackasm1(SB)
MOVL $989, CX
JMP callbackasm1(SB)
MOVL $990, CX
JMP callbackasm1(SB)
MOVL $991, CX
JMP callbackasm1(SB)
MOVL $992, CX
JMP callbackasm1(SB)
MOVL $993, CX
JMP callbackasm1(SB)
MOVL $994, CX
JMP callbackasm1(SB)
MOVL $995, CX
JMP callbackasm1(SB)
MOVL $996, CX
JMP callbackasm1(SB)
MOVL $997, CX
JMP callbackasm1(SB)
MOVL $998, CX
JMP callbackasm1(SB)
MOVL $999, CX
JMP callbackasm1(SB)
MOVL $1000, CX
JMP callbackasm1(SB)
MOVL $1001, CX
JMP callbackasm1(SB)
MOVL $1002, CX
JMP callbackasm1(SB)
MOVL $1003, CX
JMP callbackasm1(SB)
MOVL $1004, CX
JMP callbackasm1(SB)
MOVL $1005, CX
JMP callbackasm1(SB)
MOVL $1006, CX
JMP callbackasm1(SB)
MOVL $1007, CX
JMP callbackasm1(SB)
MOVL $1008, CX
JMP callbackasm1(SB)
MOVL $1009, CX
JMP callbackasm1(SB)
MOVL $1010, CX
JMP callbackasm1(SB)
MOVL $1011, CX
JMP callbackasm1(SB)
MOVL $1012, CX
JMP callbackasm1(SB)
MOVL $1013, CX
JMP callbackasm1(SB)
MOVL $1014, CX
JMP callbackasm1(SB)
MOVL $1015, CX
JMP callbackasm1(SB)
MOVL $1016, CX
JMP callbackasm1(SB)
MOVL $1017, CX
JMP callbackasm1(SB)
MOVL $1018, CX
JMP callbackasm1(SB)
MOVL $1019, CX
JMP callbackasm1(SB)
MOVL $1020, CX
JMP callbackasm1(SB)
MOVL $1021, CX
JMP callbackasm1(SB)
MOVL $1022, CX
JMP callbackasm1(SB)
MOVL $1023, CX
JMP callbackasm1(SB)
MOVL $1024, CX
JMP callbackasm1(SB)
MOVL $1025, CX
JMP callbackasm1(SB)
MOVL $1026, CX
JMP callbackasm1(SB)
MOVL $1027, CX
JMP callbackasm1(SB)
MOVL $1028, CX
JMP callbackasm1(SB)
MOVL $1029, CX
JMP callbackasm1(SB)
MOVL $1030, CX
JMP callbackasm1(SB)
MOVL $1031, CX
JMP callbackasm1(SB)
MOVL $1032, CX
JMP callbackasm1(SB)
MOVL $1033, CX
JMP callbackasm1(SB)
MOVL $1034, CX
JMP callbackasm1(SB)
MOVL $1035, CX
JMP callbackasm1(SB)
MOVL $1036, CX
JMP callbackasm1(SB)
MOVL $1037, CX
JMP callbackasm1(SB)
MOVL $1038, CX
JMP callbackasm1(SB)
MOVL $1039, CX
JMP callbackasm1(SB)
MOVL $1040, CX
JMP callbackasm1(SB)
MOVL $1041, CX
JMP callbackasm1(SB)
MOVL $1042, CX
JMP callbackasm1(SB)
MOVL $1043, CX
JMP callbackasm1(SB)
MOVL $1044, CX
JMP callbackasm1(SB)
MOVL $1045, CX
JMP callbackasm1(SB)
MOVL $1046, CX
JMP callbackasm1(SB)
MOVL $1047, CX
JMP callbackasm1(SB)
MOVL $1048, CX
JMP callbackasm1(SB)
MOVL $1049, CX
JMP callbackasm1(SB)
MOVL $1050, CX
JMP callbackasm1(SB)
MOVL $1051, CX
JMP callbackasm1(SB)
MOVL $1052, CX
JMP callbackasm1(SB)
MOVL $1053, CX
JMP callbackasm1(SB)
MOVL $1054, CX
JMP callbackasm1(SB)
MOVL $1055, CX
JMP callbackasm1(SB)
MOVL $1056, CX
JMP callbackasm1(SB)
MOVL $1057, CX
JMP callbackasm1(SB)
MOVL $1058, CX
JMP callbackasm1(SB)
MOVL $1059, CX
JMP callbackasm1(SB)
MOVL $1060, CX
JMP callbackasm1(SB)
MOVL $1061, CX
JMP callbackasm1(SB)
MOVL $1062, CX
JMP callbackasm1(SB)
MOVL $1063, CX
JMP callbackasm1(SB)
MOVL $1064, CX
JMP callbackasm1(SB)
MOVL $1065, CX
JMP callbackasm1(SB)
MOVL $1066, CX
JMP callbackasm1(SB)
MOVL $1067, CX
JMP callbackasm1(SB)
MOVL $1068, CX
JMP callbackasm1(SB)
MOVL $1069, CX
JMP callbackasm1(SB)
MOVL $1070, CX
JMP callbackasm1(SB)
MOVL $1071, CX
JMP callbackasm1(SB)
MOVL $1072, CX
JMP callbackasm1(SB)
MOVL $1073, CX
JMP callbackasm1(SB)
MOVL $1074, CX
JMP callbackasm1(SB)
MOVL $1075, CX
JMP callbackasm1(SB)
MOVL $1076, CX
JMP callbackasm1(SB)
MOVL $1077, CX
JMP callbackasm1(SB)
MOVL $1078, CX
JMP callbackasm1(SB)
MOVL $1079, CX
JMP callbackasm1(SB)
MOVL $1080, CX
JMP callbackasm1(SB)
MOVL $1081, CX
JMP callbackasm1(SB)
MOVL $1082, CX
JMP callbackasm1(SB)
MOVL $1083, CX
JMP callbackasm1(SB)
MOVL $1084, CX
JMP callbackasm1(SB)
MOVL $1085, CX
JMP callbackasm1(SB)
MOVL $1086, CX
JMP callbackasm1(SB)
MOVL $1087, CX
JMP callbackasm1(SB)
MOVL $1088, CX
JMP callbackasm1(SB)
MOVL $1089, CX
JMP callbackasm1(SB)
MOVL $1090, CX
JMP callbackasm1(SB)
MOVL $1091, CX
JMP callbackasm1(SB)
MOVL $1092, CX
JMP callbackasm1(SB)
MOVL $1093, CX
JMP callbackasm1(SB)
MOVL $1094, CX
JMP callbackasm1(SB)
MOVL $1095, CX
JMP callbackasm1(SB)
MOVL $1096, CX
JMP callbackasm1(SB)
MOVL $1097, CX
JMP callbackasm1(SB)
MOVL $1098, CX
JMP callbackasm1(SB)
MOVL $1099, CX
JMP callbackasm1(SB)
MOVL $1100, CX
JMP callbackasm1(SB)
MOVL $1101, CX
JMP callbackasm1(SB)
MOVL $1102, CX
JMP callbackasm1(SB)
MOVL $1103, CX
JMP callbackasm1(SB)
MOVL $1104, CX
JMP callbackasm1(SB)
MOVL $1105, CX
JMP callbackasm1(SB)
MOVL $1106, CX
JMP callbackasm1(SB)
MOVL $1107, CX
JMP callbackasm1(SB)
MOVL $1108, CX
JMP callbackasm1(SB)
MOVL $1109, CX
JMP callbackasm1(SB)
MOVL $1110, CX
JMP callbackasm1(SB)
MOVL $1111, CX
JMP callbackasm1(SB)
MOVL $1112, CX
JMP callbackasm1(SB)
MOVL $1113, CX
JMP callbackasm1(SB)
MOVL $1114, CX
JMP callbackasm1(SB)
MOVL $1115, CX
JMP callbackasm1(SB)
MOVL $1116, CX
JMP callbackasm1(SB)
MOVL $1117, CX
JMP callbackasm1(SB)
MOVL $1118, CX
JMP callbackasm1(SB)
MOVL $1119, CX
JMP callbackasm1(SB)
MOVL $1120, CX
JMP callbackasm1(SB)
MOVL $1121, CX
JMP callbackasm1(SB)
MOVL $1122, CX
JMP callbackasm1(SB)
MOVL $1123, CX
JMP callbackasm1(SB)
MOVL $1124, CX
JMP callbackasm1(SB)
MOVL $1125, CX
JMP callbackasm1(SB)
MOVL $1126, CX
JMP callbackasm1(SB)
MOVL $1127, CX
JMP callbackasm1(SB)
MOVL $1128, CX
JMP callbackasm1(SB)
MOVL $1129, CX
JMP callbackasm1(SB)
MOVL $1130, CX
JMP callbackasm1(SB)
MOVL $1131, CX
JMP callbackasm1(SB)
MOVL $1132, CX
JMP callbackasm1(SB)
MOVL $1133, CX
JMP callbackasm1(SB)
MOVL $1134, CX
JMP callbackasm1(SB)
MOVL $1135, CX
JMP callbackasm1(SB)
MOVL $1136, CX
JMP callbackasm1(SB)
MOVL $1137, CX
JMP callbackasm1(SB)
MOVL $1138, CX
JMP callbackasm1(SB)
MOVL $1139, CX
JMP callbackasm1(SB)
MOVL $1140, CX
JMP callbackasm1(SB)
MOVL $1141, CX
JMP callbackasm1(SB)
MOVL $1142, CX
JMP callbackasm1(SB)
MOVL $1143, CX
JMP callbackasm1(SB)
MOVL $1144, CX
JMP callbackasm1(SB)
MOVL $1145, CX
JMP callbackasm1(SB)
MOVL $1146, CX
JMP callbackasm1(SB)
MOVL $1147, CX
JMP callbackasm1(SB)
MOVL $1148, CX
JMP callbackasm1(SB)
MOVL $1149, CX
JMP callbackasm1(SB)
MOVL $1150, CX
JMP callbackasm1(SB)
MOVL $1151, CX
JMP callbackasm1(SB)
MOVL $1152, CX
JMP callbackasm1(SB)
MOVL $1153, CX
JMP callbackasm1(SB)
MOVL $1154, CX
JMP callbackasm1(SB)
MOVL $1155, CX
JMP callbackasm1(SB)
MOVL $1156, CX
JMP callbackasm1(SB)
MOVL $1157, CX
JMP callbackasm1(SB)
MOVL $1158, CX
JMP callbackasm1(SB)
MOVL $1159, CX
JMP callbackasm1(SB)
MOVL $1160, CX
JMP callbackasm1(SB)
MOVL $1161, CX
JMP callbackasm1(SB)
MOVL $1162, CX
JMP callbackasm1(SB)
MOVL $1163, CX
JMP callbackasm1(SB)
MOVL $1164, CX
JMP callbackasm1(SB)
MOVL $1165, CX
JMP callbackasm1(SB)
MOVL $1166, CX
JMP callbackasm1(SB)
MOVL $1167, CX
JMP callbackasm1(SB)
MOVL $1168, CX
JMP callbackasm1(SB)
MOVL $1169, CX
JMP callbackasm1(SB)
MOVL $1170, CX
JMP callbackasm1(SB)
MOVL $1171, CX
JMP callbackasm1(SB)
MOVL $1172, CX
JMP callbackasm1(SB)
MOVL $1173, CX
JMP callbackasm1(SB)
MOVL $1174, CX
JMP callbackasm1(SB)
MOVL $1175, CX
JMP callbackasm1(SB)
MOVL $1176, CX
JMP callbackasm1(SB)
MOVL $1177, CX
JMP callbackasm1(SB)
MOVL $1178, CX
JMP callbackasm1(SB)
MOVL $1179, CX
JMP callbackasm1(SB)
MOVL $1180, CX
JMP callbackasm1(SB)
MOVL $1181, CX
JMP callbackasm1(SB)
MOVL $1182, CX
JMP callbackasm1(SB)
MOVL $1183, CX
JMP callbackasm1(SB)
MOVL $1184, CX
JMP callbackasm1(SB)
MOVL $1185, CX
JMP callbackasm1(SB)
MOVL $1186, CX
JMP callbackasm1(SB)
MOVL $1187, CX
JMP callbackasm1(SB)
MOVL $1188, CX
JMP callbackasm1(SB)
MOVL $1189, CX
JMP callbackasm1(SB)
MOVL $1190, CX
JMP callbackasm1(SB)
MOVL $1191, CX
JMP callbackasm1(SB)
MOVL $1192, CX
JMP callbackasm1(SB)
MOVL $1193, CX
JMP callbackasm1(SB)
MOVL $1194, CX
JMP callbackasm1(SB)
MOVL $1195, CX
JMP callbackasm1(SB)
MOVL $1196, CX
JMP callbackasm1(SB)
MOVL $1197, CX
JMP callbackasm1(SB)
MOVL $1198, CX
JMP callbackasm1(SB)
MOVL $1199, CX
JMP callbackasm1(SB)
MOVL $1200, CX
JMP callbackasm1(SB)
MOVL $1201, CX
JMP callbackasm1(SB)
MOVL $1202, CX
JMP callbackasm1(SB)
MOVL $1203, CX
JMP callbackasm1(SB)
MOVL $1204, CX
JMP callbackasm1(SB)
MOVL $1205, CX
JMP callbackasm1(SB)
MOVL $1206, CX
JMP callbackasm1(SB)
MOVL $1207, CX
JMP callbackasm1(SB)
MOVL $1208, CX
JMP callbackasm1(SB)
MOVL $1209, CX
JMP callbackasm1(SB)
MOVL $1210, CX
JMP callbackasm1(SB)
MOVL $1211, CX
JMP callbackasm1(SB)
MOVL $1212, CX
JMP callbackasm1(SB)
MOVL $1213, CX
JMP callbackasm1(SB)
MOVL $1214, CX
JMP callbackasm1(SB)
MOVL $1215, CX
JMP callbackasm1(SB)
MOVL $1216, CX
JMP callbackasm1(SB)
MOVL $1217, CX
JMP callbackasm1(SB)
MOVL $1218, CX
JMP callbackasm1(SB)
MOVL $1219, CX
JMP callbackasm1(SB)
MOVL $1220, CX
JMP callbackasm1(SB)
MOVL $1221, CX
JMP callbackasm1(SB)
MOVL $1222, CX
JMP callbackasm1(SB)
MOVL $1223, CX
JMP callbackasm1(SB)
MOVL $1224, CX
JMP callbackasm1(SB)
MOVL $1225, CX
JMP callbackasm1(SB)
MOVL $1226, CX
JMP callbackasm1(SB)
MOVL $1227, CX
JMP callbackasm1(SB)
MOVL $1228, CX
JMP callbackasm1(SB)
MOVL $1229, CX
JMP callbackasm1(SB)
MOVL $1230, CX
JMP callbackasm1(SB)
MOVL $1231, CX
JMP callbackasm1(SB)
MOVL $1232, CX
JMP callbackasm1(SB)
MOVL $1233, CX
JMP callbackasm1(SB)
MOVL $1234, CX
JMP callbackasm1(SB)
MOVL $1235, CX
JMP callbackasm1(SB)
MOVL $1236, CX
JMP callbackasm1(SB)
MOVL $1237, CX
JMP callbackasm1(SB)
MOVL $1238, CX
JMP callbackasm1(SB)
MOVL $1239, CX
JMP callbackasm1(SB)
MOVL $1240, CX
JMP callbackasm1(SB)
MOVL $1241, CX
JMP callbackasm1(SB)
MOVL $1242, CX
JMP callbackasm1(SB)
MOVL $1243, CX
JMP callbackasm1(SB)
MOVL $1244, CX
JMP callbackasm1(SB)
MOVL $1245, CX
JMP callbackasm1(SB)
MOVL $1246, CX
JMP callbackasm1(SB)
MOVL $1247, CX
JMP callbackasm1(SB)
MOVL $1248, CX
JMP callbackasm1(SB)
MOVL $1249, CX
JMP callbackasm1(SB)
MOVL $1250, CX
JMP callbackasm1(SB)
MOVL $1251, CX
JMP callbackasm1(SB)
MOVL $1252, CX
JMP callbackasm1(SB)
MOVL $1253, CX
JMP callbackasm1(SB)
MOVL $1254, CX
JMP callbackasm1(SB)
MOVL $1255, CX
JMP callbackasm1(SB)
MOVL $1256, CX
JMP callbackasm1(SB)
MOVL $1257, CX
JMP callbackasm1(SB)
MOVL $1258, CX
JMP callbackasm1(SB)
MOVL $1259, CX
JMP callbackasm1(SB)
MOVL $1260, CX
JMP callbackasm1(SB)
MOVL $1261, CX
JMP callbackasm1(SB)
MOVL $1262, CX
JMP callbackasm1(SB)
MOVL $1263, CX
JMP callbackasm1(SB)
MOVL $1264, CX
JMP callbackasm1(SB)
MOVL $1265, CX
JMP callbackasm1(SB)
MOVL $1266, CX
JMP callbackasm1(SB)
MOVL $1267, CX
JMP callbackasm1(SB)
MOVL $1268, CX
JMP callbackasm1(SB)
MOVL $1269, CX
JMP callbackasm1(SB)
MOVL $1270, CX
JMP callbackasm1(SB)
MOVL $1271, CX
JMP callbackasm1(SB)
MOVL $1272, CX
JMP callbackasm1(SB)
MOVL $1273, CX
JMP callbackasm1(SB)
MOVL $1274, CX
JMP callbackasm1(SB)
MOVL $1275, CX
JMP callbackasm1(SB)
MOVL $1276, CX
JMP callbackasm1(SB)
MOVL $1277, CX
JMP callbackasm1(SB)
MOVL $1278, CX
JMP callbackasm1(SB)
MOVL $1279, CX
JMP callbackasm1(SB)
MOVL $1280, CX
JMP callbackasm1(SB)
MOVL $1281, CX
JMP callbackasm1(SB)
MOVL $1282, CX
JMP callbackasm1(SB)
MOVL $1283, CX
JMP callbackasm1(SB)
MOVL $1284, CX
JMP callbackasm1(SB)
MOVL $1285, CX
JMP callbackasm1(SB)
MOVL $1286, CX
JMP callbackasm1(SB)
MOVL $1287, CX
JMP callbackasm1(SB)
MOVL $1288, CX
JMP callbackasm1(SB)
MOVL $1289, CX
JMP callbackasm1(SB)
MOVL $1290, CX
JMP callbackasm1(SB)
MOVL $1291, CX
JMP callbackasm1(SB)
MOVL $1292, CX
JMP callbackasm1(SB)
MOVL $1293, CX
JMP callbackasm1(SB)
MOVL $1294, CX
JMP callbackasm1(SB)
MOVL $1295, CX
JMP callbackasm1(SB)
MOVL $1296, CX
JMP callbackasm1(SB)
MOVL $1297, CX
JMP callbackasm1(SB)
MOVL $1298, CX
JMP callbackasm1(SB)
MOVL $1299, CX
JMP callbackasm1(SB)
MOVL $1300, CX
JMP callbackasm1(SB)
MOVL $1301, CX
JMP callbackasm1(SB)
MOVL $1302, CX
JMP callbackasm1(SB)
MOVL $1303, CX
JMP callbackasm1(SB)
MOVL $1304, CX
JMP callbackasm1(SB)
MOVL $1305, CX
JMP callbackasm1(SB)
MOVL $1306, CX
JMP callbackasm1(SB)
MOVL $1307, CX
JMP callbackasm1(SB)
MOVL $1308, CX
JMP callbackasm1(SB)
MOVL $1309, CX
JMP callbackasm1(SB)
MOVL $1310, CX
JMP callbackasm1(SB)
MOVL $1311, CX
JMP callbackasm1(SB)
MOVL $1312, CX
JMP callbackasm1(SB)
MOVL $1313, CX
JMP callbackasm1(SB)
MOVL $1314, CX
JMP callbackasm1(SB)
MOVL $1315, CX
JMP callbackasm1(SB)
MOVL $1316, CX
JMP callbackasm1(SB)
MOVL $1317, CX
JMP callbackasm1(SB)
MOVL $1318, CX
JMP callbackasm1(SB)
MOVL $1319, CX
JMP callbackasm1(SB)
MOVL $1320, CX
JMP callbackasm1(SB)
MOVL $1321, CX
JMP callbackasm1(SB)
MOVL $1322, CX
JMP callbackasm1(SB)
MOVL $1323, CX
JMP callbackasm1(SB)
MOVL $1324, CX
JMP callbackasm1(SB)
MOVL $1325, CX
JMP callbackasm1(SB)
MOVL $1326, CX
JMP callbackasm1(SB)
MOVL $1327, CX
JMP callbackasm1(SB)
MOVL $1328, CX
JMP callbackasm1(SB)
MOVL $1329, CX
JMP callbackasm1(SB)
MOVL $1330, CX
JMP callbackasm1(SB)
MOVL $1331, CX
JMP callbackasm1(SB)
MOVL $1332, CX
JMP callbackasm1(SB)
MOVL $1333, CX
JMP callbackasm1(SB)
MOVL $1334, CX
JMP callbackasm1(SB)
MOVL $1335, CX
JMP callbackasm1(SB)
MOVL $1336, CX
JMP callbackasm1(SB)
MOVL $1337, CX
JMP callbackasm1(SB)
MOVL $1338, CX
JMP callbackasm1(SB)
MOVL $1339, CX
JMP callbackasm1(SB)
MOVL $1340, CX
JMP callbackasm1(SB)
MOVL $1341, CX
JMP callbackasm1(SB)
MOVL $1342, CX
JMP callbackasm1(SB)
MOVL $1343, CX
JMP callbackasm1(SB)
MOVL $1344, CX
JMP callbackasm1(SB)
MOVL $1345, CX
JMP callbackasm1(SB)
MOVL $1346, CX
JMP callbackasm1(SB)
MOVL $1347, CX
JMP callbackasm1(SB)
MOVL $1348, CX
JMP callbackasm1(SB)
MOVL $1349, CX
JMP callbackasm1(SB)
MOVL $1350, CX
JMP callbackasm1(SB)
MOVL $1351, CX
JMP callbackasm1(SB)
MOVL $1352, CX
JMP callbackasm1(SB)
MOVL $1353, CX
JMP callbackasm1(SB)
MOVL $1354, CX
JMP callbackasm1(SB)
MOVL $1355, CX
JMP callbackasm1(SB)
MOVL $1356, CX
JMP callbackasm1(SB)
MOVL $1357, CX
JMP callbackasm1(SB)
MOVL $1358, CX
JMP callbackasm1(SB)
MOVL $1359, CX
JMP callbackasm1(SB)
MOVL $1360, CX
JMP callbackasm1(SB)
MOVL $1361, CX
JMP callbackasm1(SB)
MOVL $1362, CX
JMP callbackasm1(SB)
MOVL $1363, CX
JMP callbackasm1(SB)
MOVL $1364, CX
JMP callbackasm1(SB)
MOVL $1365, CX
JMP callbackasm1(SB)
MOVL $1366, CX
JMP callbackasm1(SB)
MOVL $1367, CX
JMP callbackasm1(SB)
MOVL $1368, CX
JMP callbackasm1(SB)
MOVL $1369, CX
JMP callbackasm1(SB)
MOVL $1370, CX
JMP callbackasm1(SB)
MOVL $1371, CX
JMP callbackasm1(SB)
MOVL $1372, CX
JMP callbackasm1(SB)
MOVL $1373, CX
JMP callbackasm1(SB)
MOVL $1374, CX
JMP callbackasm1(SB)
MOVL $1375, CX
JMP callbackasm1(SB)
MOVL $1376, CX
JMP callbackasm1(SB)
MOVL $1377, CX
JMP callbackasm1(SB)
MOVL $1378, CX
JMP callbackasm1(SB)
MOVL $1379, CX
JMP callbackasm1(SB)
MOVL $1380, CX
JMP callbackasm1(SB)
MOVL $1381, CX
JMP callbackasm1(SB)
MOVL $1382, CX
JMP callbackasm1(SB)
MOVL $1383, CX
JMP callbackasm1(SB)
MOVL $1384, CX
JMP callbackasm1(SB)
MOVL $1385, CX
JMP callbackasm1(SB)
MOVL $1386, CX
JMP callbackasm1(SB)
MOVL $1387, CX
JMP callbackasm1(SB)
MOVL $1388, CX
JMP callbackasm1(SB)
MOVL $1389, CX
JMP callbackasm1(SB)
MOVL $1390, CX
JMP callbackasm1(SB)
MOVL $1391, CX
JMP callbackasm1(SB)
MOVL $1392, CX
JMP callbackasm1(SB)
MOVL $1393, CX
JMP callbackasm1(SB)
MOVL $1394, CX
JMP callbackasm1(SB)
MOVL $1395, CX
JMP callbackasm1(SB)
MOVL $1396, CX
JMP callbackasm1(SB)
MOVL $1397, CX
JMP callbackasm1(SB)
MOVL $1398, CX
JMP callbackasm1(SB)
MOVL $1399, CX
JMP callbackasm1(SB)
MOVL $1400, CX
JMP callbackasm1(SB)
MOVL $1401, CX
JMP callbackasm1(SB)
MOVL $1402, CX
JMP callbackasm1(SB)
MOVL $1403, CX
JMP callbackasm1(SB)
MOVL $1404, CX
JMP callbackasm1(SB)
MOVL $1405, CX
JMP callbackasm1(SB)
MOVL $1406, CX
JMP callbackasm1(SB)
MOVL $1407, CX
JMP callbackasm1(SB)
MOVL $1408, CX
JMP callbackasm1(SB)
MOVL $1409, CX
JMP callbackasm1(SB)
MOVL $1410, CX
JMP callbackasm1(SB)
MOVL $1411, CX
JMP callbackasm1(SB)
MOVL $1412, CX
JMP callbackasm1(SB)
MOVL $1413, CX
JMP callbackasm1(SB)
MOVL $1414, CX
JMP callbackasm1(SB)
MOVL $1415, CX
JMP callbackasm1(SB)
MOVL $1416, CX
JMP callbackasm1(SB)
MOVL $1417, CX
JMP callbackasm1(SB)
MOVL $1418, CX
JMP callbackasm1(SB)
MOVL $1419, CX
JMP callbackasm1(SB)
MOVL $1420, CX
JMP callbackasm1(SB)
MOVL $1421, CX
JMP callbackasm1(SB)
MOVL $1422, CX
JMP callbackasm1(SB)
MOVL $1423, CX
JMP callbackasm1(SB)
MOVL $1424, CX
JMP callbackasm1(SB)
MOVL $1425, CX
JMP callbackasm1(SB)
MOVL $1426, CX
JMP callbackasm1(SB)
MOVL $1427, CX
JMP callbackasm1(SB)
MOVL $1428, CX
JMP callbackasm1(SB)
MOVL $1429, CX
JMP callbackasm1(SB)
MOVL $1430, CX
JMP callbackasm1(SB)
MOVL $1431, CX
JMP callbackasm1(SB)
MOVL $1432, CX
JMP callbackasm1(SB)
MOVL $1433, CX
JMP callbackasm1(SB)
MOVL $1434, CX
JMP callbackasm1(SB)
MOVL $1435, CX
JMP callbackasm1(SB)
MOVL $1436, CX
JMP callbackasm1(SB)
MOVL $1437, CX
JMP callbackasm1(SB)
MOVL $1438, CX
JMP callbackasm1(SB)
MOVL $1439, CX
JMP callbackasm1(SB)
MOVL $1440, CX
JMP callbackasm1(SB)
MOVL $1441, CX
JMP callbackasm1(SB)
MOVL $1442, CX
JMP callbackasm1(SB)
MOVL $1443, CX
JMP callbackasm1(SB)
MOVL $1444, CX
JMP callbackasm1(SB)
MOVL $1445, CX
JMP callbackasm1(SB)
MOVL $1446, CX
JMP callbackasm1(SB)
MOVL $1447, CX
JMP callbackasm1(SB)
MOVL $1448, CX
JMP callbackasm1(SB)
MOVL $1449, CX
JMP callbackasm1(SB)
MOVL $1450, CX
JMP callbackasm1(SB)
MOVL $1451, CX
JMP callbackasm1(SB)
MOVL $1452, CX
JMP callbackasm1(SB)
MOVL $1453, CX
JMP callbackasm1(SB)
MOVL $1454, CX
JMP callbackasm1(SB)
MOVL $1455, CX
JMP callbackasm1(SB)
MOVL $1456, CX
JMP callbackasm1(SB)
MOVL $1457, CX
JMP callbackasm1(SB)
MOVL $1458, CX
JMP callbackasm1(SB)
MOVL $1459, CX
JMP callbackasm1(SB)
MOVL $1460, CX
JMP callbackasm1(SB)
MOVL $1461, CX
JMP callbackasm1(SB)
MOVL $1462, CX
JMP callbackasm1(SB)
MOVL $1463, CX
JMP callbackasm1(SB)
MOVL $1464, CX
JMP callbackasm1(SB)
MOVL $1465, CX
JMP callbackasm1(SB)
MOVL $1466, CX
JMP callbackasm1(SB)
MOVL $1467, CX
JMP callbackasm1(SB)
MOVL $1468, CX
JMP callbackasm1(SB)
MOVL $1469, CX
JMP callbackasm1(SB)
MOVL $1470, CX
JMP callbackasm1(SB)
MOVL $1471, CX
JMP callbackasm1(SB)
MOVL $1472, CX
JMP callbackasm1(SB)
MOVL $1473, CX
JMP callbackasm1(SB)
MOVL $1474, CX
JMP callbackasm1(SB)
MOVL $1475, CX
JMP callbackasm1(SB)
MOVL $1476, CX
JMP callbackasm1(SB)
MOVL $1477, CX
JMP callbackasm1(SB)
MOVL $1478, CX
JMP callbackasm1(SB)
MOVL $1479, CX
JMP callbackasm1(SB)
MOVL $1480, CX
JMP callbackasm1(SB)
MOVL $1481, CX
JMP callbackasm1(SB)
MOVL $1482, CX
JMP callbackasm1(SB)
MOVL $1483, CX
JMP callbackasm1(SB)
MOVL $1484, CX
JMP callbackasm1(SB)
MOVL $1485, CX
JMP callbackasm1(SB)
MOVL $1486, CX
JMP callbackasm1(SB)
MOVL $1487, CX
JMP callbackasm1(SB)
MOVL $1488, CX
JMP callbackasm1(SB)
MOVL $1489, CX
JMP callbackasm1(SB)
MOVL $1490, CX
JMP callbackasm1(SB)
MOVL $1491, CX
JMP callbackasm1(SB)
MOVL $1492, CX
JMP callbackasm1(SB)
MOVL $1493, CX
JMP callbackasm1(SB)
MOVL $1494, CX
JMP callbackasm1(SB)
MOVL $1495, CX
JMP callbackasm1(SB)
MOVL $1496, CX
JMP callbackasm1(SB)
MOVL $1497, CX
JMP callbackasm1(SB)
MOVL $1498, CX
JMP callbackasm1(SB)
MOVL $1499, CX
JMP callbackasm1(SB)
MOVL $1500, CX
JMP callbackasm1(SB)
MOVL $1501, CX
JMP callbackasm1(SB)
MOVL $1502, CX
JMP callbackasm1(SB)
MOVL $1503, CX
JMP callbackasm1(SB)
MOVL $1504, CX
JMP callbackasm1(SB)
MOVL $1505, CX
JMP callbackasm1(SB)
MOVL $1506, CX
JMP callbackasm1(SB)
MOVL $1507, CX
JMP callbackasm1(SB)
MOVL $1508, CX
JMP callbackasm1(SB)
MOVL $1509, CX
JMP callbackasm1(SB)
MOVL $1510, CX
JMP callbackasm1(SB)
MOVL $1511, CX
JMP callbackasm1(SB)
MOVL $1512, CX
JMP callbackasm1(SB)
MOVL $1513, CX
JMP callbackasm1(SB)
MOVL $1514, CX
JMP callbackasm1(SB)
MOVL $1515, CX
JMP callbackasm1(SB)
MOVL $1516, CX
JMP callbackasm1(SB)
MOVL $1517, CX
JMP callbackasm1(SB)
MOVL $1518, CX
JMP callbackasm1(SB)
MOVL $1519, CX
JMP callbackasm1(SB)
MOVL $1520, CX
JMP callbackasm1(SB)
MOVL $1521, CX
JMP callbackasm1(SB)
MOVL $1522, CX
JMP callbackasm1(SB)
MOVL $1523, CX
JMP callbackasm1(SB)
MOVL $1524, CX
JMP callbackasm1(SB)
MOVL $1525, CX
JMP callbackasm1(SB)
MOVL $1526, CX
JMP callbackasm1(SB)
MOVL $1527, CX
JMP callbackasm1(SB)
MOVL $1528, CX
JMP callbackasm1(SB)
MOVL $1529, CX
JMP callbackasm1(SB)
MOVL $1530, CX
JMP callbackasm1(SB)
MOVL $1531, CX
JMP callbackasm1(SB)
MOVL $1532, CX
JMP callbackasm1(SB)
MOVL $1533, CX
JMP callbackasm1(SB)
MOVL $1534, CX
JMP callbackasm1(SB)
MOVL $1535, CX
JMP callbackasm1(SB)
MOVL $1536, CX
JMP callbackasm1(SB)
MOVL $1537, CX
JMP callbackasm1(SB)
MOVL $1538, CX
JMP callbackasm1(SB)
MOVL $1539, CX
JMP callbackasm1(SB)
MOVL $1540, CX
JMP callbackasm1(SB)
MOVL $1541, CX
JMP callbackasm1(SB)
MOVL $1542, CX
JMP callbackasm1(SB)
MOVL $1543, CX
JMP callbackasm1(SB)
MOVL $1544, CX
JMP callbackasm1(SB)
MOVL $1545, CX
JMP callbackasm1(SB)
MOVL $1546, CX
JMP callbackasm1(SB)
MOVL $1547, CX
JMP callbackasm1(SB)
MOVL $1548, CX
JMP callbackasm1(SB)
MOVL $1549, CX
JMP callbackasm1(SB)
MOVL $1550, CX
JMP callbackasm1(SB)
MOVL $1551, CX
JMP callbackasm1(SB)
MOVL $1552, CX
JMP callbackasm1(SB)
MOVL $1553, CX
JMP callbackasm1(SB)
MOVL $1554, CX
JMP callbackasm1(SB)
MOVL $1555, CX
JMP callbackasm1(SB)
MOVL $1556, CX
JMP callbackasm1(SB)
MOVL $1557, CX
JMP callbackasm1(SB)
MOVL $1558, CX
JMP callbackasm1(SB)
MOVL $1559, CX
JMP callbackasm1(SB)
MOVL $1560, CX
JMP callbackasm1(SB)
MOVL $1561, CX
JMP callbackasm1(SB)
MOVL $1562, CX
JMP callbackasm1(SB)
MOVL $1563, CX
JMP callbackasm1(SB)
MOVL $1564, CX
JMP callbackasm1(SB)
MOVL $1565, CX
JMP callbackasm1(SB)
MOVL $1566, CX
JMP callbackasm1(SB)
MOVL $1567, CX
JMP callbackasm1(SB)
MOVL $1568, CX
JMP callbackasm1(SB)
MOVL $1569, CX
JMP callbackasm1(SB)
MOVL $1570, CX
JMP callbackasm1(SB)
MOVL $1571, CX
JMP callbackasm1(SB)
MOVL $1572, CX
JMP callbackasm1(SB)
MOVL $1573, CX
JMP callbackasm1(SB)
MOVL $1574, CX
JMP callbackasm1(SB)
MOVL $1575, CX
JMP callbackasm1(SB)
MOVL $1576, CX
JMP callbackasm1(SB)
MOVL $1577, CX
JMP callbackasm1(SB)
MOVL $1578, CX
JMP callbackasm1(SB)
MOVL $1579, CX
JMP callbackasm1(SB)
MOVL $1580, CX
JMP callbackasm1(SB)
MOVL $1581, CX
JMP callbackasm1(SB)
MOVL $1582, CX
JMP callbackasm1(SB)
MOVL $1583, CX
JMP callbackasm1(SB)
MOVL $1584, CX
JMP callbackasm1(SB)
MOVL $1585, CX
JMP callbackasm1(SB)
MOVL $1586, CX
JMP callbackasm1(SB)
MOVL $1587, CX
JMP callbackasm1(SB)
MOVL $1588, CX
JMP callbackasm1(SB)
MOVL $1589, CX
JMP callbackasm1(SB)
MOVL $1590, CX
JMP callbackasm1(SB)
MOVL $1591, CX
JMP callbackasm1(SB)
MOVL $1592, CX
JMP callbackasm1(SB)
MOVL $1593, CX
JMP callbackasm1(SB)
MOVL $1594, CX
JMP callbackasm1(SB)
MOVL $1595, CX
JMP callbackasm1(SB)
MOVL $1596, CX
JMP callbackasm1(SB)
MOVL $1597, CX
JMP callbackasm1(SB)
MOVL $1598, CX
JMP callbackasm1(SB)
MOVL $1599, CX
JMP callbackasm1(SB)
MOVL $1600, CX
JMP callbackasm1(SB)
MOVL $1601, CX
JMP callbackasm1(SB)
MOVL $1602, CX
JMP callbackasm1(SB)
MOVL $1603, CX
JMP callbackasm1(SB)
MOVL $1604, CX
JMP callbackasm1(SB)
MOVL $1605, CX
JMP callbackasm1(SB)
MOVL $1606, CX
JMP callbackasm1(SB)
MOVL $1607, CX
JMP callbackasm1(SB)
MOVL $1608, CX
JMP callbackasm1(SB)
MOVL $1609, CX
JMP callbackasm1(SB)
MOVL $1610, CX
JMP callbackasm1(SB)
MOVL $1611, CX
JMP callbackasm1(SB)
MOVL $1612, CX
JMP callbackasm1(SB)
MOVL $1613, CX
JMP callbackasm1(SB)
MOVL $1614, CX
JMP callbackasm1(SB)
MOVL $1615, CX
JMP callbackasm1(SB)
MOVL $1616, CX
JMP callbackasm1(SB)
MOVL $1617, CX
JMP callbackasm1(SB)
MOVL $1618, CX
JMP callbackasm1(SB)
MOVL $1619, CX
JMP callbackasm1(SB)
MOVL $1620, CX
JMP callbackasm1(SB)
MOVL $1621, CX
JMP callbackasm1(SB)
MOVL $1622, CX
JMP callbackasm1(SB)
MOVL $1623, CX
JMP callbackasm1(SB)
MOVL $1624, CX
JMP callbackasm1(SB)
MOVL $1625, CX
JMP callbackasm1(SB)
MOVL $1626, CX
JMP callbackasm1(SB)
MOVL $1627, CX
JMP callbackasm1(SB)
MOVL $1628, CX
JMP callbackasm1(SB)
MOVL $1629, CX
JMP callbackasm1(SB)
MOVL $1630, CX
JMP callbackasm1(SB)
MOVL $1631, CX
JMP callbackasm1(SB)
MOVL $1632, CX
JMP callbackasm1(SB)
MOVL $1633, CX
JMP callbackasm1(SB)
MOVL $1634, CX
JMP callbackasm1(SB)
MOVL $1635, CX
JMP callbackasm1(SB)
MOVL $1636, CX
JMP callbackasm1(SB)
MOVL $1637, CX
JMP callbackasm1(SB)
MOVL $1638, CX
JMP callbackasm1(SB)
MOVL $1639, CX
JMP callbackasm1(SB)
MOVL $1640, CX
JMP callbackasm1(SB)
MOVL $1641, CX
JMP callbackasm1(SB)
MOVL $1642, CX
JMP callbackasm1(SB)
MOVL $1643, CX
JMP callbackasm1(SB)
MOVL $1644, CX
JMP callbackasm1(SB)
MOVL $1645, CX
JMP callbackasm1(SB)
MOVL $1646, CX
JMP callbackasm1(SB)
MOVL $1647, CX
JMP callbackasm1(SB)
MOVL $1648, CX
JMP callbackasm1(SB)
MOVL $1649, CX
JMP callbackasm1(SB)
MOVL $1650, CX
JMP callbackasm1(SB)
MOVL $1651, CX
JMP callbackasm1(SB)
MOVL $1652, CX
JMP callbackasm1(SB)
MOVL $1653, CX
JMP callbackasm1(SB)
MOVL $1654, CX
JMP callbackasm1(SB)
MOVL $1655, CX
JMP callbackasm1(SB)
MOVL $1656, CX
JMP callbackasm1(SB)
MOVL $1657, CX
JMP callbackasm1(SB)
MOVL $1658, CX
JMP callbackasm1(SB)
MOVL $1659, CX
JMP callbackasm1(SB)
MOVL $1660, CX
JMP callbackasm1(SB)
MOVL $1661, CX
JMP callbackasm1(SB)
MOVL $1662, CX
JMP callbackasm1(SB)
MOVL $1663, CX
JMP callbackasm1(SB)
MOVL $1664, CX
JMP callbackasm1(SB)
MOVL $1665, CX
JMP callbackasm1(SB)
MOVL $1666, CX
JMP callbackasm1(SB)
MOVL $1667, CX
JMP callbackasm1(SB)
MOVL $1668, CX
JMP callbackasm1(SB)
MOVL $1669, CX
JMP callbackasm1(SB)
MOVL $1670, CX
JMP callbackasm1(SB)
MOVL $1671, CX
JMP callbackasm1(SB)
MOVL $1672, CX
JMP callbackasm1(SB)
MOVL $1673, CX
JMP callbackasm1(SB)
MOVL $1674, CX
JMP callbackasm1(SB)
MOVL $1675, CX
JMP callbackasm1(SB)
MOVL $1676, CX
JMP callbackasm1(SB)
MOVL $1677, CX
JMP callbackasm1(SB)
MOVL $1678, CX
JMP callbackasm1(SB)
MOVL $1679, CX
JMP callbackasm1(SB)
MOVL $1680, CX
JMP callbackasm1(SB)
MOVL $1681, CX
JMP callbackasm1(SB)
MOVL $1682, CX
JMP callbackasm1(SB)
MOVL $1683, CX
JMP callbackasm1(SB)
MOVL $1684, CX
JMP callbackasm1(SB)
MOVL $1685, CX
JMP callbackasm1(SB)
MOVL $1686, CX
JMP callbackasm1(SB)
MOVL $1687, CX
JMP callbackasm1(SB)
MOVL $1688, CX
JMP callbackasm1(SB)
MOVL $1689, CX
JMP callbackasm1(SB)
MOVL $1690, CX
JMP callbackasm1(SB)
MOVL $1691, CX
JMP callbackasm1(SB)
MOVL $1692, CX
JMP callbackasm1(SB)
MOVL $1693, CX
JMP callbackasm1(SB)
MOVL $1694, CX
JMP callbackasm1(SB)
MOVL $1695, CX
JMP callbackasm1(SB)
MOVL $1696, CX
JMP callbackasm1(SB)
MOVL $1697, CX
JMP callbackasm1(SB)
MOVL $1698, CX
JMP callbackasm1(SB)
MOVL $1699, CX
JMP callbackasm1(SB)
MOVL $1700, CX
JMP callbackasm1(SB)
MOVL $1701, CX
JMP callbackasm1(SB)
MOVL $1702, CX
JMP callbackasm1(SB)
MOVL $1703, CX
JMP callbackasm1(SB)
MOVL $1704, CX
JMP callbackasm1(SB)
MOVL $1705, CX
JMP callbackasm1(SB)
MOVL $1706, CX
JMP callbackasm1(SB)
MOVL $1707, CX
JMP callbackasm1(SB)
MOVL $1708, CX
JMP callbackasm1(SB)
MOVL $1709, CX
JMP callbackasm1(SB)
MOVL $1710, CX
JMP callbackasm1(SB)
MOVL $1711, CX
JMP callbackasm1(SB)
MOVL $1712, CX
JMP callbackasm1(SB)
MOVL $1713, CX
JMP callbackasm1(SB)
MOVL $1714, CX
JMP callbackasm1(SB)
MOVL $1715, CX
JMP callbackasm1(SB)
MOVL $1716, CX
JMP callbackasm1(SB)
MOVL $1717, CX
JMP callbackasm1(SB)
MOVL $1718, CX
JMP callbackasm1(SB)
MOVL $1719, CX
JMP callbackasm1(SB)
MOVL $1720, CX
JMP callbackasm1(SB)
MOVL $1721, CX
JMP callbackasm1(SB)
MOVL $1722, CX
JMP callbackasm1(SB)
MOVL $1723, CX
JMP callbackasm1(SB)
MOVL $1724, CX
JMP callbackasm1(SB)
MOVL $1725, CX
JMP callbackasm1(SB)
MOVL $1726, CX
JMP callbackasm1(SB)
MOVL $1727, CX
JMP callbackasm1(SB)
MOVL $1728, CX
JMP callbackasm1(SB)
MOVL $1729, CX
JMP callbackasm1(SB)
MOVL $1730, CX
JMP callbackasm1(SB)
MOVL $1731, CX
JMP callbackasm1(SB)
MOVL $1732, CX
JMP callbackasm1(SB)
MOVL $1733, CX
JMP callbackasm1(SB)
MOVL $1734, CX
JMP callbackasm1(SB)
MOVL $1735, CX
JMP callbackasm1(SB)
MOVL $1736, CX
JMP callbackasm1(SB)
MOVL $1737, CX
JMP callbackasm1(SB)
MOVL $1738, CX
JMP callbackasm1(SB)
MOVL $1739, CX
JMP callbackasm1(SB)
MOVL $1740, CX
JMP callbackasm1(SB)
MOVL $1741, CX
JMP callbackasm1(SB)
MOVL $1742, CX
JMP callbackasm1(SB)
MOVL $1743, CX
JMP callbackasm1(SB)
MOVL $1744, CX
JMP callbackasm1(SB)
MOVL $1745, CX
JMP callbackasm1(SB)
MOVL $1746, CX
JMP callbackasm1(SB)
MOVL $1747, CX
JMP callbackasm1(SB)
MOVL $1748, CX
JMP callbackasm1(SB)
MOVL $1749, CX
JMP callbackasm1(SB)
MOVL $1750, CX
JMP callbackasm1(SB)
MOVL $1751, CX
JMP callbackasm1(SB)
MOVL $1752, CX
JMP callbackasm1(SB)
MOVL $1753, CX
JMP callbackasm1(SB)
MOVL $1754, CX
JMP callbackasm1(SB)
MOVL $1755, CX
JMP callbackasm1(SB)
MOVL $1756, CX
JMP callbackasm1(SB)
MOVL $1757, CX
JMP callbackasm1(SB)
MOVL $1758, CX
JMP callbackasm1(SB)
MOVL $1759, CX
JMP callbackasm1(SB)
MOVL $1760, CX
JMP callbackasm1(SB)
MOVL $1761, CX
JMP callbackasm1(SB)
MOVL $1762, CX
JMP callbackasm1(SB)
MOVL $1763, CX
JMP callbackasm1(SB)
MOVL $1764, CX
JMP callbackasm1(SB)
MOVL $1765, CX
JMP callbackasm1(SB)
MOVL $1766, CX
JMP callbackasm1(SB)
MOVL $1767, CX
JMP callbackasm1(SB)
MOVL $1768, CX
JMP callbackasm1(SB)
MOVL $1769, CX
JMP callbackasm1(SB)
MOVL $1770, CX
JMP callbackasm1(SB)
MOVL $1771, CX
JMP callbackasm1(SB)
MOVL $1772, CX
JMP callbackasm1(SB)
MOVL $1773, CX
JMP callbackasm1(SB)
MOVL $1774, CX
JMP callbackasm1(SB)
MOVL $1775, CX
JMP callbackasm1(SB)
MOVL $1776, CX
JMP callbackasm1(SB)
MOVL $1777, CX
JMP callbackasm1(SB)
MOVL $1778, CX
JMP callbackasm1(SB)
MOVL $1779, CX
JMP callbackasm1(SB)
MOVL $1780, CX
JMP callbackasm1(SB)
MOVL $1781, CX
JMP callbackasm1(SB)
MOVL $1782, CX
JMP callbackasm1(SB)
MOVL $1783, CX
JMP callbackasm1(SB)
MOVL $1784, CX
JMP callbackasm1(SB)
MOVL $1785, CX
JMP callbackasm1(SB)
MOVL $1786, CX
JMP callbackasm1(SB)
MOVL $1787, CX
JMP callbackasm1(SB)
MOVL $1788, CX
JMP callbackasm1(SB)
MOVL $1789, CX
JMP callbackasm1(SB)
MOVL $1790, CX
JMP callbackasm1(SB)
MOVL $1791, CX
JMP callbackasm1(SB)
MOVL $1792, CX
JMP callbackasm1(SB)
MOVL $1793, CX
JMP callbackasm1(SB)
MOVL $1794, CX
JMP callbackasm1(SB)
MOVL $1795, CX
JMP callbackasm1(SB)
MOVL $1796, CX
JMP callbackasm1(SB)
MOVL $1797, CX
JMP callbackasm1(SB)
MOVL $1798, CX
JMP callbackasm1(SB)
MOVL $1799, CX
JMP callbackasm1(SB)
MOVL $1800, CX
JMP callbackasm1(SB)
MOVL $1801, CX
JMP callbackasm1(SB)
MOVL $1802, CX
JMP callbackasm1(SB)
MOVL $1803, CX
JMP callbackasm1(SB)
MOVL $1804, CX
JMP callbackasm1(SB)
MOVL $1805, CX
JMP callbackasm1(SB)
MOVL $1806, CX
JMP callbackasm1(SB)
MOVL $1807, CX
JMP callbackasm1(SB)
MOVL $1808, CX
JMP callbackasm1(SB)
MOVL $1809, CX
JMP callbackasm1(SB)
MOVL $1810, CX
JMP callbackasm1(SB)
MOVL $1811, CX
JMP callbackasm1(SB)
MOVL $1812, CX
JMP callbackasm1(SB)
MOVL $1813, CX
JMP callbackasm1(SB)
MOVL $1814, CX
JMP callbackasm1(SB)
MOVL $1815, CX
JMP callbackasm1(SB)
MOVL $1816, CX
JMP callbackasm1(SB)
MOVL $1817, CX
JMP callbackasm1(SB)
MOVL $1818, CX
JMP callbackasm1(SB)
MOVL $1819, CX
JMP callbackasm1(SB)
MOVL $1820, CX
JMP callbackasm1(SB)
MOVL $1821, CX
JMP callbackasm1(SB)
MOVL $1822, CX
JMP callbackasm1(SB)
MOVL $1823, CX
JMP callbackasm1(SB)
MOVL $1824, CX
JMP callbackasm1(SB)
MOVL $1825, CX
JMP callbackasm1(SB)
MOVL $1826, CX
JMP callbackasm1(SB)
MOVL $1827, CX
JMP callbackasm1(SB)
MOVL $1828, CX
JMP callbackasm1(SB)
MOVL $1829, CX
JMP callbackasm1(SB)
MOVL $1830, CX
JMP callbackasm1(SB)
MOVL $1831, CX
JMP callbackasm1(SB)
MOVL $1832, CX
JMP callbackasm1(SB)
MOVL $1833, CX
JMP callbackasm1(SB)
MOVL $1834, CX
JMP callbackasm1(SB)
MOVL $1835, CX
JMP callbackasm1(SB)
MOVL $1836, CX
JMP callbackasm1(SB)
MOVL $1837, CX
JMP callbackasm1(SB)
MOVL $1838, CX
JMP callbackasm1(SB)
MOVL $1839, CX
JMP callbackasm1(SB)
MOVL $1840, CX
JMP callbackasm1(SB)
MOVL $1841, CX
JMP callbackasm1(SB)
MOVL $1842, CX
JMP callbackasm1(SB)
MOVL $1843, CX
JMP callbackasm1(SB)
MOVL $1844, CX
JMP callbackasm1(SB)
MOVL $1845, CX
JMP callbackasm1(SB)
MOVL $1846, CX
JMP callbackasm1(SB)
MOVL $1847, CX
JMP callbackasm1(SB)
MOVL $1848, CX
JMP callbackasm1(SB)
MOVL $1849, CX
JMP callbackasm1(SB)
MOVL $1850, CX
JMP callbackasm1(SB)
MOVL $1851, CX
JMP callbackasm1(SB)
MOVL $1852, CX
JMP callbackasm1(SB)
MOVL $1853, CX
JMP callbackasm1(SB)
MOVL $1854, CX
JMP callbackasm1(SB)
MOVL $1855, CX
JMP callbackasm1(SB)
MOVL $1856, CX
JMP callbackasm1(SB)
MOVL $1857, CX
JMP callbackasm1(SB)
MOVL $1858, CX
JMP callbackasm1(SB)
MOVL $1859, CX
JMP callbackasm1(SB)
MOVL $1860, CX
JMP callbackasm1(SB)
MOVL $1861, CX
JMP callbackasm1(SB)
MOVL $1862, CX
JMP callbackasm1(SB)
MOVL $1863, CX
JMP callbackasm1(SB)
MOVL $1864, CX
JMP callbackasm1(SB)
MOVL $1865, CX
JMP callbackasm1(SB)
MOVL $1866, CX
JMP callbackasm1(SB)
MOVL $1867, CX
JMP callbackasm1(SB)
MOVL $1868, CX
JMP callbackasm1(SB)
MOVL $1869, CX
JMP callbackasm1(SB)
MOVL $1870, CX
JMP callbackasm1(SB)
MOVL $1871, CX
JMP callbackasm1(SB)
MOVL $1872, CX
JMP callbackasm1(SB)
MOVL $1873, CX
JMP callbackasm1(SB)
MOVL $1874, CX
JMP callbackasm1(SB)
MOVL $1875, CX
JMP callbackasm1(SB)
MOVL $1876, CX
JMP callbackasm1(SB)
MOVL $1877, CX
JMP callbackasm1(SB)
MOVL $1878, CX
JMP callbackasm1(SB)
MOVL $1879, CX
JMP callbackasm1(SB)
MOVL $1880, CX
JMP callbackasm1(SB)
MOVL $1881, CX
JMP callbackasm1(SB)
MOVL $1882, CX
JMP callbackasm1(SB)
MOVL $1883, CX
JMP callbackasm1(SB)
MOVL $1884, CX
JMP callbackasm1(SB)
MOVL $1885, CX
JMP callbackasm1(SB)
MOVL $1886, CX
JMP callbackasm1(SB)
MOVL $1887, CX
JMP callbackasm1(SB)
MOVL $1888, CX
JMP callbackasm1(SB)
MOVL $1889, CX
JMP callbackasm1(SB)
MOVL $1890, CX
JMP callbackasm1(SB)
MOVL $1891, CX
JMP callbackasm1(SB)
MOVL $1892, CX
JMP callbackasm1(SB)
MOVL $1893, CX
JMP callbackasm1(SB)
MOVL $1894, CX
JMP callbackasm1(SB)
MOVL $1895, CX
JMP callbackasm1(SB)
MOVL $1896, CX
JMP callbackasm1(SB)
MOVL $1897, CX
JMP callbackasm1(SB)
MOVL $1898, CX
JMP callbackasm1(SB)
MOVL $1899, CX
JMP callbackasm1(SB)
MOVL $1900, CX
JMP callbackasm1(SB)
MOVL $1901, CX
JMP callbackasm1(SB)
MOVL $1902, CX
JMP callbackasm1(SB)
MOVL $1903, CX
JMP callbackasm1(SB)
MOVL $1904, CX
JMP callbackasm1(SB)
MOVL $1905, CX
JMP callbackasm1(SB)
MOVL $1906, CX
JMP callbackasm1(SB)
MOVL $1907, CX
JMP callbackasm1(SB)
MOVL $1908, CX
JMP callbackasm1(SB)
MOVL $1909, CX
JMP callbackasm1(SB)
MOVL $1910, CX
JMP callbackasm1(SB)
MOVL $1911, CX
JMP callbackasm1(SB)
MOVL $1912, CX
JMP callbackasm1(SB)
MOVL $1913, CX
JMP callbackasm1(SB)
MOVL $1914, CX
JMP callbackasm1(SB)
MOVL $1915, CX
JMP callbackasm1(SB)
MOVL $1916, CX
JMP callbackasm1(SB)
MOVL $1917, CX
JMP callbackasm1(SB)
MOVL $1918, CX
JMP callbackasm1(SB)
MOVL $1919, CX
JMP callbackasm1(SB)
MOVL $1920, CX
JMP callbackasm1(SB)
MOVL $1921, CX
JMP callbackasm1(SB)
MOVL $1922, CX
JMP callbackasm1(SB)
MOVL $1923, CX
JMP callbackasm1(SB)
MOVL $1924, CX
JMP callbackasm1(SB)
MOVL $1925, CX
JMP callbackasm1(SB)
MOVL $1926, CX
JMP callbackasm1(SB)
MOVL $1927, CX
JMP callbackasm1(SB)
MOVL $1928, CX
JMP callbackasm1(SB)
MOVL $1929, CX
JMP callbackasm1(SB)
MOVL $1930, CX
JMP callbackasm1(SB)
MOVL $1931, CX
JMP callbackasm1(SB)
MOVL $1932, CX
JMP callbackasm1(SB)
MOVL $1933, CX
JMP callbackasm1(SB)
MOVL $1934, CX
JMP callbackasm1(SB)
MOVL $1935, CX
JMP callbackasm1(SB)
MOVL $1936, CX
JMP callbackasm1(SB)
MOVL $1937, CX
JMP callbackasm1(SB)
MOVL $1938, CX
JMP callbackasm1(SB)
MOVL $1939, CX
JMP callbackasm1(SB)
MOVL $1940, CX
JMP callbackasm1(SB)
MOVL $1941, CX
JMP callbackasm1(SB)
MOVL $1942, CX
JMP callbackasm1(SB)
MOVL $1943, CX
JMP callbackasm1(SB)
MOVL $1944, CX
JMP callbackasm1(SB)
MOVL $1945, CX
JMP callbackasm1(SB)
MOVL $1946, CX
JMP callbackasm1(SB)
MOVL $1947, CX
JMP callbackasm1(SB)
MOVL $1948, CX
JMP callbackasm1(SB)
MOVL $1949, CX
JMP callbackasm1(SB)
MOVL $1950, CX
JMP callbackasm1(SB)
MOVL $1951, CX
JMP callbackasm1(SB)
MOVL $1952, CX
JMP callbackasm1(SB)
MOVL $1953, CX
JMP callbackasm1(SB)
MOVL $1954, CX
JMP callbackasm1(SB)
MOVL $1955, CX
JMP callbackasm1(SB)
MOVL $1956, CX
JMP callbackasm1(SB)
MOVL $1957, CX
JMP callbackasm1(SB)
MOVL $1958, CX
JMP callbackasm1(SB)
MOVL $1959, CX
JMP callbackasm1(SB)
MOVL $1960, CX
JMP callbackasm1(SB)
MOVL $1961, CX
JMP callbackasm1(SB)
MOVL $1962, CX
JMP callbackasm1(SB)
MOVL $1963, CX
JMP callbackasm1(SB)
MOVL $1964, CX
JMP callbackasm1(SB)
MOVL $1965, CX
JMP callbackasm1(SB)
MOVL $1966, CX
JMP callbackasm1(SB)
MOVL $1967, CX
JMP callbackasm1(SB)
MOVL $1968, CX
JMP callbackasm1(SB)
MOVL $1969, CX
JMP callbackasm1(SB)
MOVL $1970, CX
JMP callbackasm1(SB)
MOVL $1971, CX
JMP callbackasm1(SB)
MOVL $1972, CX
JMP callbackasm1(SB)
MOVL $1973, CX
JMP callbackasm1(SB)
MOVL $1974, CX
JMP callbackasm1(SB)
MOVL $1975, CX
JMP callbackasm1(SB)
MOVL $1976, CX
JMP callbackasm1(SB)
MOVL $1977, CX
JMP callbackasm1(SB)
MOVL $1978, CX
JMP callbackasm1(SB)
MOVL $1979, CX
JMP callbackasm1(SB)
MOVL $1980, CX
JMP callbackasm1(SB)
MOVL $1981, CX
JMP callbackasm1(SB)
MOVL $1982, CX
JMP callbackasm1(SB)
MOVL $1983, CX
JMP callbackasm1(SB)
MOVL $1984, CX
JMP callbackasm1(SB)
MOVL $1985, CX
JMP callbackasm1(SB)
MOVL $1986, CX
JMP callbackasm1(SB)
MOVL $1987, CX
JMP callbackasm1(SB)
MOVL $1988, CX
JMP callbackasm1(SB)
MOVL $1989, CX
JMP callbackasm1(SB)
MOVL $1990, CX
JMP callbackasm1(SB)
MOVL $1991, CX
JMP callbackasm1(SB)
MOVL $1992, CX
JMP callbackasm1(SB)
MOVL $1993, CX
JMP callbackasm1(SB)
MOVL $1994, CX
JMP callbackasm1(SB)
MOVL $1995, CX
JMP callbackasm1(SB)
MOVL $1996, CX
JMP callbackasm1(SB)
MOVL $1997, CX
JMP callbackasm1(SB)
MOVL $1998, CX
JMP callbackasm1(SB)
MOVL $1999, CX
JMP callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_amd64.s 0000664 0000000 0000000 00000132772 15207302613 0023046 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// runtime·callbackasm is called by external code to
// execute Go implemented callback function. It is not
// called from the start, instead runtime·compilecallback
// always returns address into runtime·callbackasm offset
// appropriately so different callbacks start with different
// CALL instruction in runtime·callbackasm. This determines
// which Go callback function is executed later on.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
CALL callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_arm.s 0000664 0000000 0000000 00000233170 15207302613 0022704 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVW and B instructions.
// The MOVW instruction loads R12 with the callback index, and the
// B instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVW $0, R12
B callbackasm1(SB)
MOVW $1, R12
B callbackasm1(SB)
MOVW $2, R12
B callbackasm1(SB)
MOVW $3, R12
B callbackasm1(SB)
MOVW $4, R12
B callbackasm1(SB)
MOVW $5, R12
B callbackasm1(SB)
MOVW $6, R12
B callbackasm1(SB)
MOVW $7, R12
B callbackasm1(SB)
MOVW $8, R12
B callbackasm1(SB)
MOVW $9, R12
B callbackasm1(SB)
MOVW $10, R12
B callbackasm1(SB)
MOVW $11, R12
B callbackasm1(SB)
MOVW $12, R12
B callbackasm1(SB)
MOVW $13, R12
B callbackasm1(SB)
MOVW $14, R12
B callbackasm1(SB)
MOVW $15, R12
B callbackasm1(SB)
MOVW $16, R12
B callbackasm1(SB)
MOVW $17, R12
B callbackasm1(SB)
MOVW $18, R12
B callbackasm1(SB)
MOVW $19, R12
B callbackasm1(SB)
MOVW $20, R12
B callbackasm1(SB)
MOVW $21, R12
B callbackasm1(SB)
MOVW $22, R12
B callbackasm1(SB)
MOVW $23, R12
B callbackasm1(SB)
MOVW $24, R12
B callbackasm1(SB)
MOVW $25, R12
B callbackasm1(SB)
MOVW $26, R12
B callbackasm1(SB)
MOVW $27, R12
B callbackasm1(SB)
MOVW $28, R12
B callbackasm1(SB)
MOVW $29, R12
B callbackasm1(SB)
MOVW $30, R12
B callbackasm1(SB)
MOVW $31, R12
B callbackasm1(SB)
MOVW $32, R12
B callbackasm1(SB)
MOVW $33, R12
B callbackasm1(SB)
MOVW $34, R12
B callbackasm1(SB)
MOVW $35, R12
B callbackasm1(SB)
MOVW $36, R12
B callbackasm1(SB)
MOVW $37, R12
B callbackasm1(SB)
MOVW $38, R12
B callbackasm1(SB)
MOVW $39, R12
B callbackasm1(SB)
MOVW $40, R12
B callbackasm1(SB)
MOVW $41, R12
B callbackasm1(SB)
MOVW $42, R12
B callbackasm1(SB)
MOVW $43, R12
B callbackasm1(SB)
MOVW $44, R12
B callbackasm1(SB)
MOVW $45, R12
B callbackasm1(SB)
MOVW $46, R12
B callbackasm1(SB)
MOVW $47, R12
B callbackasm1(SB)
MOVW $48, R12
B callbackasm1(SB)
MOVW $49, R12
B callbackasm1(SB)
MOVW $50, R12
B callbackasm1(SB)
MOVW $51, R12
B callbackasm1(SB)
MOVW $52, R12
B callbackasm1(SB)
MOVW $53, R12
B callbackasm1(SB)
MOVW $54, R12
B callbackasm1(SB)
MOVW $55, R12
B callbackasm1(SB)
MOVW $56, R12
B callbackasm1(SB)
MOVW $57, R12
B callbackasm1(SB)
MOVW $58, R12
B callbackasm1(SB)
MOVW $59, R12
B callbackasm1(SB)
MOVW $60, R12
B callbackasm1(SB)
MOVW $61, R12
B callbackasm1(SB)
MOVW $62, R12
B callbackasm1(SB)
MOVW $63, R12
B callbackasm1(SB)
MOVW $64, R12
B callbackasm1(SB)
MOVW $65, R12
B callbackasm1(SB)
MOVW $66, R12
B callbackasm1(SB)
MOVW $67, R12
B callbackasm1(SB)
MOVW $68, R12
B callbackasm1(SB)
MOVW $69, R12
B callbackasm1(SB)
MOVW $70, R12
B callbackasm1(SB)
MOVW $71, R12
B callbackasm1(SB)
MOVW $72, R12
B callbackasm1(SB)
MOVW $73, R12
B callbackasm1(SB)
MOVW $74, R12
B callbackasm1(SB)
MOVW $75, R12
B callbackasm1(SB)
MOVW $76, R12
B callbackasm1(SB)
MOVW $77, R12
B callbackasm1(SB)
MOVW $78, R12
B callbackasm1(SB)
MOVW $79, R12
B callbackasm1(SB)
MOVW $80, R12
B callbackasm1(SB)
MOVW $81, R12
B callbackasm1(SB)
MOVW $82, R12
B callbackasm1(SB)
MOVW $83, R12
B callbackasm1(SB)
MOVW $84, R12
B callbackasm1(SB)
MOVW $85, R12
B callbackasm1(SB)
MOVW $86, R12
B callbackasm1(SB)
MOVW $87, R12
B callbackasm1(SB)
MOVW $88, R12
B callbackasm1(SB)
MOVW $89, R12
B callbackasm1(SB)
MOVW $90, R12
B callbackasm1(SB)
MOVW $91, R12
B callbackasm1(SB)
MOVW $92, R12
B callbackasm1(SB)
MOVW $93, R12
B callbackasm1(SB)
MOVW $94, R12
B callbackasm1(SB)
MOVW $95, R12
B callbackasm1(SB)
MOVW $96, R12
B callbackasm1(SB)
MOVW $97, R12
B callbackasm1(SB)
MOVW $98, R12
B callbackasm1(SB)
MOVW $99, R12
B callbackasm1(SB)
MOVW $100, R12
B callbackasm1(SB)
MOVW $101, R12
B callbackasm1(SB)
MOVW $102, R12
B callbackasm1(SB)
MOVW $103, R12
B callbackasm1(SB)
MOVW $104, R12
B callbackasm1(SB)
MOVW $105, R12
B callbackasm1(SB)
MOVW $106, R12
B callbackasm1(SB)
MOVW $107, R12
B callbackasm1(SB)
MOVW $108, R12
B callbackasm1(SB)
MOVW $109, R12
B callbackasm1(SB)
MOVW $110, R12
B callbackasm1(SB)
MOVW $111, R12
B callbackasm1(SB)
MOVW $112, R12
B callbackasm1(SB)
MOVW $113, R12
B callbackasm1(SB)
MOVW $114, R12
B callbackasm1(SB)
MOVW $115, R12
B callbackasm1(SB)
MOVW $116, R12
B callbackasm1(SB)
MOVW $117, R12
B callbackasm1(SB)
MOVW $118, R12
B callbackasm1(SB)
MOVW $119, R12
B callbackasm1(SB)
MOVW $120, R12
B callbackasm1(SB)
MOVW $121, R12
B callbackasm1(SB)
MOVW $122, R12
B callbackasm1(SB)
MOVW $123, R12
B callbackasm1(SB)
MOVW $124, R12
B callbackasm1(SB)
MOVW $125, R12
B callbackasm1(SB)
MOVW $126, R12
B callbackasm1(SB)
MOVW $127, R12
B callbackasm1(SB)
MOVW $128, R12
B callbackasm1(SB)
MOVW $129, R12
B callbackasm1(SB)
MOVW $130, R12
B callbackasm1(SB)
MOVW $131, R12
B callbackasm1(SB)
MOVW $132, R12
B callbackasm1(SB)
MOVW $133, R12
B callbackasm1(SB)
MOVW $134, R12
B callbackasm1(SB)
MOVW $135, R12
B callbackasm1(SB)
MOVW $136, R12
B callbackasm1(SB)
MOVW $137, R12
B callbackasm1(SB)
MOVW $138, R12
B callbackasm1(SB)
MOVW $139, R12
B callbackasm1(SB)
MOVW $140, R12
B callbackasm1(SB)
MOVW $141, R12
B callbackasm1(SB)
MOVW $142, R12
B callbackasm1(SB)
MOVW $143, R12
B callbackasm1(SB)
MOVW $144, R12
B callbackasm1(SB)
MOVW $145, R12
B callbackasm1(SB)
MOVW $146, R12
B callbackasm1(SB)
MOVW $147, R12
B callbackasm1(SB)
MOVW $148, R12
B callbackasm1(SB)
MOVW $149, R12
B callbackasm1(SB)
MOVW $150, R12
B callbackasm1(SB)
MOVW $151, R12
B callbackasm1(SB)
MOVW $152, R12
B callbackasm1(SB)
MOVW $153, R12
B callbackasm1(SB)
MOVW $154, R12
B callbackasm1(SB)
MOVW $155, R12
B callbackasm1(SB)
MOVW $156, R12
B callbackasm1(SB)
MOVW $157, R12
B callbackasm1(SB)
MOVW $158, R12
B callbackasm1(SB)
MOVW $159, R12
B callbackasm1(SB)
MOVW $160, R12
B callbackasm1(SB)
MOVW $161, R12
B callbackasm1(SB)
MOVW $162, R12
B callbackasm1(SB)
MOVW $163, R12
B callbackasm1(SB)
MOVW $164, R12
B callbackasm1(SB)
MOVW $165, R12
B callbackasm1(SB)
MOVW $166, R12
B callbackasm1(SB)
MOVW $167, R12
B callbackasm1(SB)
MOVW $168, R12
B callbackasm1(SB)
MOVW $169, R12
B callbackasm1(SB)
MOVW $170, R12
B callbackasm1(SB)
MOVW $171, R12
B callbackasm1(SB)
MOVW $172, R12
B callbackasm1(SB)
MOVW $173, R12
B callbackasm1(SB)
MOVW $174, R12
B callbackasm1(SB)
MOVW $175, R12
B callbackasm1(SB)
MOVW $176, R12
B callbackasm1(SB)
MOVW $177, R12
B callbackasm1(SB)
MOVW $178, R12
B callbackasm1(SB)
MOVW $179, R12
B callbackasm1(SB)
MOVW $180, R12
B callbackasm1(SB)
MOVW $181, R12
B callbackasm1(SB)
MOVW $182, R12
B callbackasm1(SB)
MOVW $183, R12
B callbackasm1(SB)
MOVW $184, R12
B callbackasm1(SB)
MOVW $185, R12
B callbackasm1(SB)
MOVW $186, R12
B callbackasm1(SB)
MOVW $187, R12
B callbackasm1(SB)
MOVW $188, R12
B callbackasm1(SB)
MOVW $189, R12
B callbackasm1(SB)
MOVW $190, R12
B callbackasm1(SB)
MOVW $191, R12
B callbackasm1(SB)
MOVW $192, R12
B callbackasm1(SB)
MOVW $193, R12
B callbackasm1(SB)
MOVW $194, R12
B callbackasm1(SB)
MOVW $195, R12
B callbackasm1(SB)
MOVW $196, R12
B callbackasm1(SB)
MOVW $197, R12
B callbackasm1(SB)
MOVW $198, R12
B callbackasm1(SB)
MOVW $199, R12
B callbackasm1(SB)
MOVW $200, R12
B callbackasm1(SB)
MOVW $201, R12
B callbackasm1(SB)
MOVW $202, R12
B callbackasm1(SB)
MOVW $203, R12
B callbackasm1(SB)
MOVW $204, R12
B callbackasm1(SB)
MOVW $205, R12
B callbackasm1(SB)
MOVW $206, R12
B callbackasm1(SB)
MOVW $207, R12
B callbackasm1(SB)
MOVW $208, R12
B callbackasm1(SB)
MOVW $209, R12
B callbackasm1(SB)
MOVW $210, R12
B callbackasm1(SB)
MOVW $211, R12
B callbackasm1(SB)
MOVW $212, R12
B callbackasm1(SB)
MOVW $213, R12
B callbackasm1(SB)
MOVW $214, R12
B callbackasm1(SB)
MOVW $215, R12
B callbackasm1(SB)
MOVW $216, R12
B callbackasm1(SB)
MOVW $217, R12
B callbackasm1(SB)
MOVW $218, R12
B callbackasm1(SB)
MOVW $219, R12
B callbackasm1(SB)
MOVW $220, R12
B callbackasm1(SB)
MOVW $221, R12
B callbackasm1(SB)
MOVW $222, R12
B callbackasm1(SB)
MOVW $223, R12
B callbackasm1(SB)
MOVW $224, R12
B callbackasm1(SB)
MOVW $225, R12
B callbackasm1(SB)
MOVW $226, R12
B callbackasm1(SB)
MOVW $227, R12
B callbackasm1(SB)
MOVW $228, R12
B callbackasm1(SB)
MOVW $229, R12
B callbackasm1(SB)
MOVW $230, R12
B callbackasm1(SB)
MOVW $231, R12
B callbackasm1(SB)
MOVW $232, R12
B callbackasm1(SB)
MOVW $233, R12
B callbackasm1(SB)
MOVW $234, R12
B callbackasm1(SB)
MOVW $235, R12
B callbackasm1(SB)
MOVW $236, R12
B callbackasm1(SB)
MOVW $237, R12
B callbackasm1(SB)
MOVW $238, R12
B callbackasm1(SB)
MOVW $239, R12
B callbackasm1(SB)
MOVW $240, R12
B callbackasm1(SB)
MOVW $241, R12
B callbackasm1(SB)
MOVW $242, R12
B callbackasm1(SB)
MOVW $243, R12
B callbackasm1(SB)
MOVW $244, R12
B callbackasm1(SB)
MOVW $245, R12
B callbackasm1(SB)
MOVW $246, R12
B callbackasm1(SB)
MOVW $247, R12
B callbackasm1(SB)
MOVW $248, R12
B callbackasm1(SB)
MOVW $249, R12
B callbackasm1(SB)
MOVW $250, R12
B callbackasm1(SB)
MOVW $251, R12
B callbackasm1(SB)
MOVW $252, R12
B callbackasm1(SB)
MOVW $253, R12
B callbackasm1(SB)
MOVW $254, R12
B callbackasm1(SB)
MOVW $255, R12
B callbackasm1(SB)
MOVW $256, R12
B callbackasm1(SB)
MOVW $257, R12
B callbackasm1(SB)
MOVW $258, R12
B callbackasm1(SB)
MOVW $259, R12
B callbackasm1(SB)
MOVW $260, R12
B callbackasm1(SB)
MOVW $261, R12
B callbackasm1(SB)
MOVW $262, R12
B callbackasm1(SB)
MOVW $263, R12
B callbackasm1(SB)
MOVW $264, R12
B callbackasm1(SB)
MOVW $265, R12
B callbackasm1(SB)
MOVW $266, R12
B callbackasm1(SB)
MOVW $267, R12
B callbackasm1(SB)
MOVW $268, R12
B callbackasm1(SB)
MOVW $269, R12
B callbackasm1(SB)
MOVW $270, R12
B callbackasm1(SB)
MOVW $271, R12
B callbackasm1(SB)
MOVW $272, R12
B callbackasm1(SB)
MOVW $273, R12
B callbackasm1(SB)
MOVW $274, R12
B callbackasm1(SB)
MOVW $275, R12
B callbackasm1(SB)
MOVW $276, R12
B callbackasm1(SB)
MOVW $277, R12
B callbackasm1(SB)
MOVW $278, R12
B callbackasm1(SB)
MOVW $279, R12
B callbackasm1(SB)
MOVW $280, R12
B callbackasm1(SB)
MOVW $281, R12
B callbackasm1(SB)
MOVW $282, R12
B callbackasm1(SB)
MOVW $283, R12
B callbackasm1(SB)
MOVW $284, R12
B callbackasm1(SB)
MOVW $285, R12
B callbackasm1(SB)
MOVW $286, R12
B callbackasm1(SB)
MOVW $287, R12
B callbackasm1(SB)
MOVW $288, R12
B callbackasm1(SB)
MOVW $289, R12
B callbackasm1(SB)
MOVW $290, R12
B callbackasm1(SB)
MOVW $291, R12
B callbackasm1(SB)
MOVW $292, R12
B callbackasm1(SB)
MOVW $293, R12
B callbackasm1(SB)
MOVW $294, R12
B callbackasm1(SB)
MOVW $295, R12
B callbackasm1(SB)
MOVW $296, R12
B callbackasm1(SB)
MOVW $297, R12
B callbackasm1(SB)
MOVW $298, R12
B callbackasm1(SB)
MOVW $299, R12
B callbackasm1(SB)
MOVW $300, R12
B callbackasm1(SB)
MOVW $301, R12
B callbackasm1(SB)
MOVW $302, R12
B callbackasm1(SB)
MOVW $303, R12
B callbackasm1(SB)
MOVW $304, R12
B callbackasm1(SB)
MOVW $305, R12
B callbackasm1(SB)
MOVW $306, R12
B callbackasm1(SB)
MOVW $307, R12
B callbackasm1(SB)
MOVW $308, R12
B callbackasm1(SB)
MOVW $309, R12
B callbackasm1(SB)
MOVW $310, R12
B callbackasm1(SB)
MOVW $311, R12
B callbackasm1(SB)
MOVW $312, R12
B callbackasm1(SB)
MOVW $313, R12
B callbackasm1(SB)
MOVW $314, R12
B callbackasm1(SB)
MOVW $315, R12
B callbackasm1(SB)
MOVW $316, R12
B callbackasm1(SB)
MOVW $317, R12
B callbackasm1(SB)
MOVW $318, R12
B callbackasm1(SB)
MOVW $319, R12
B callbackasm1(SB)
MOVW $320, R12
B callbackasm1(SB)
MOVW $321, R12
B callbackasm1(SB)
MOVW $322, R12
B callbackasm1(SB)
MOVW $323, R12
B callbackasm1(SB)
MOVW $324, R12
B callbackasm1(SB)
MOVW $325, R12
B callbackasm1(SB)
MOVW $326, R12
B callbackasm1(SB)
MOVW $327, R12
B callbackasm1(SB)
MOVW $328, R12
B callbackasm1(SB)
MOVW $329, R12
B callbackasm1(SB)
MOVW $330, R12
B callbackasm1(SB)
MOVW $331, R12
B callbackasm1(SB)
MOVW $332, R12
B callbackasm1(SB)
MOVW $333, R12
B callbackasm1(SB)
MOVW $334, R12
B callbackasm1(SB)
MOVW $335, R12
B callbackasm1(SB)
MOVW $336, R12
B callbackasm1(SB)
MOVW $337, R12
B callbackasm1(SB)
MOVW $338, R12
B callbackasm1(SB)
MOVW $339, R12
B callbackasm1(SB)
MOVW $340, R12
B callbackasm1(SB)
MOVW $341, R12
B callbackasm1(SB)
MOVW $342, R12
B callbackasm1(SB)
MOVW $343, R12
B callbackasm1(SB)
MOVW $344, R12
B callbackasm1(SB)
MOVW $345, R12
B callbackasm1(SB)
MOVW $346, R12
B callbackasm1(SB)
MOVW $347, R12
B callbackasm1(SB)
MOVW $348, R12
B callbackasm1(SB)
MOVW $349, R12
B callbackasm1(SB)
MOVW $350, R12
B callbackasm1(SB)
MOVW $351, R12
B callbackasm1(SB)
MOVW $352, R12
B callbackasm1(SB)
MOVW $353, R12
B callbackasm1(SB)
MOVW $354, R12
B callbackasm1(SB)
MOVW $355, R12
B callbackasm1(SB)
MOVW $356, R12
B callbackasm1(SB)
MOVW $357, R12
B callbackasm1(SB)
MOVW $358, R12
B callbackasm1(SB)
MOVW $359, R12
B callbackasm1(SB)
MOVW $360, R12
B callbackasm1(SB)
MOVW $361, R12
B callbackasm1(SB)
MOVW $362, R12
B callbackasm1(SB)
MOVW $363, R12
B callbackasm1(SB)
MOVW $364, R12
B callbackasm1(SB)
MOVW $365, R12
B callbackasm1(SB)
MOVW $366, R12
B callbackasm1(SB)
MOVW $367, R12
B callbackasm1(SB)
MOVW $368, R12
B callbackasm1(SB)
MOVW $369, R12
B callbackasm1(SB)
MOVW $370, R12
B callbackasm1(SB)
MOVW $371, R12
B callbackasm1(SB)
MOVW $372, R12
B callbackasm1(SB)
MOVW $373, R12
B callbackasm1(SB)
MOVW $374, R12
B callbackasm1(SB)
MOVW $375, R12
B callbackasm1(SB)
MOVW $376, R12
B callbackasm1(SB)
MOVW $377, R12
B callbackasm1(SB)
MOVW $378, R12
B callbackasm1(SB)
MOVW $379, R12
B callbackasm1(SB)
MOVW $380, R12
B callbackasm1(SB)
MOVW $381, R12
B callbackasm1(SB)
MOVW $382, R12
B callbackasm1(SB)
MOVW $383, R12
B callbackasm1(SB)
MOVW $384, R12
B callbackasm1(SB)
MOVW $385, R12
B callbackasm1(SB)
MOVW $386, R12
B callbackasm1(SB)
MOVW $387, R12
B callbackasm1(SB)
MOVW $388, R12
B callbackasm1(SB)
MOVW $389, R12
B callbackasm1(SB)
MOVW $390, R12
B callbackasm1(SB)
MOVW $391, R12
B callbackasm1(SB)
MOVW $392, R12
B callbackasm1(SB)
MOVW $393, R12
B callbackasm1(SB)
MOVW $394, R12
B callbackasm1(SB)
MOVW $395, R12
B callbackasm1(SB)
MOVW $396, R12
B callbackasm1(SB)
MOVW $397, R12
B callbackasm1(SB)
MOVW $398, R12
B callbackasm1(SB)
MOVW $399, R12
B callbackasm1(SB)
MOVW $400, R12
B callbackasm1(SB)
MOVW $401, R12
B callbackasm1(SB)
MOVW $402, R12
B callbackasm1(SB)
MOVW $403, R12
B callbackasm1(SB)
MOVW $404, R12
B callbackasm1(SB)
MOVW $405, R12
B callbackasm1(SB)
MOVW $406, R12
B callbackasm1(SB)
MOVW $407, R12
B callbackasm1(SB)
MOVW $408, R12
B callbackasm1(SB)
MOVW $409, R12
B callbackasm1(SB)
MOVW $410, R12
B callbackasm1(SB)
MOVW $411, R12
B callbackasm1(SB)
MOVW $412, R12
B callbackasm1(SB)
MOVW $413, R12
B callbackasm1(SB)
MOVW $414, R12
B callbackasm1(SB)
MOVW $415, R12
B callbackasm1(SB)
MOVW $416, R12
B callbackasm1(SB)
MOVW $417, R12
B callbackasm1(SB)
MOVW $418, R12
B callbackasm1(SB)
MOVW $419, R12
B callbackasm1(SB)
MOVW $420, R12
B callbackasm1(SB)
MOVW $421, R12
B callbackasm1(SB)
MOVW $422, R12
B callbackasm1(SB)
MOVW $423, R12
B callbackasm1(SB)
MOVW $424, R12
B callbackasm1(SB)
MOVW $425, R12
B callbackasm1(SB)
MOVW $426, R12
B callbackasm1(SB)
MOVW $427, R12
B callbackasm1(SB)
MOVW $428, R12
B callbackasm1(SB)
MOVW $429, R12
B callbackasm1(SB)
MOVW $430, R12
B callbackasm1(SB)
MOVW $431, R12
B callbackasm1(SB)
MOVW $432, R12
B callbackasm1(SB)
MOVW $433, R12
B callbackasm1(SB)
MOVW $434, R12
B callbackasm1(SB)
MOVW $435, R12
B callbackasm1(SB)
MOVW $436, R12
B callbackasm1(SB)
MOVW $437, R12
B callbackasm1(SB)
MOVW $438, R12
B callbackasm1(SB)
MOVW $439, R12
B callbackasm1(SB)
MOVW $440, R12
B callbackasm1(SB)
MOVW $441, R12
B callbackasm1(SB)
MOVW $442, R12
B callbackasm1(SB)
MOVW $443, R12
B callbackasm1(SB)
MOVW $444, R12
B callbackasm1(SB)
MOVW $445, R12
B callbackasm1(SB)
MOVW $446, R12
B callbackasm1(SB)
MOVW $447, R12
B callbackasm1(SB)
MOVW $448, R12
B callbackasm1(SB)
MOVW $449, R12
B callbackasm1(SB)
MOVW $450, R12
B callbackasm1(SB)
MOVW $451, R12
B callbackasm1(SB)
MOVW $452, R12
B callbackasm1(SB)
MOVW $453, R12
B callbackasm1(SB)
MOVW $454, R12
B callbackasm1(SB)
MOVW $455, R12
B callbackasm1(SB)
MOVW $456, R12
B callbackasm1(SB)
MOVW $457, R12
B callbackasm1(SB)
MOVW $458, R12
B callbackasm1(SB)
MOVW $459, R12
B callbackasm1(SB)
MOVW $460, R12
B callbackasm1(SB)
MOVW $461, R12
B callbackasm1(SB)
MOVW $462, R12
B callbackasm1(SB)
MOVW $463, R12
B callbackasm1(SB)
MOVW $464, R12
B callbackasm1(SB)
MOVW $465, R12
B callbackasm1(SB)
MOVW $466, R12
B callbackasm1(SB)
MOVW $467, R12
B callbackasm1(SB)
MOVW $468, R12
B callbackasm1(SB)
MOVW $469, R12
B callbackasm1(SB)
MOVW $470, R12
B callbackasm1(SB)
MOVW $471, R12
B callbackasm1(SB)
MOVW $472, R12
B callbackasm1(SB)
MOVW $473, R12
B callbackasm1(SB)
MOVW $474, R12
B callbackasm1(SB)
MOVW $475, R12
B callbackasm1(SB)
MOVW $476, R12
B callbackasm1(SB)
MOVW $477, R12
B callbackasm1(SB)
MOVW $478, R12
B callbackasm1(SB)
MOVW $479, R12
B callbackasm1(SB)
MOVW $480, R12
B callbackasm1(SB)
MOVW $481, R12
B callbackasm1(SB)
MOVW $482, R12
B callbackasm1(SB)
MOVW $483, R12
B callbackasm1(SB)
MOVW $484, R12
B callbackasm1(SB)
MOVW $485, R12
B callbackasm1(SB)
MOVW $486, R12
B callbackasm1(SB)
MOVW $487, R12
B callbackasm1(SB)
MOVW $488, R12
B callbackasm1(SB)
MOVW $489, R12
B callbackasm1(SB)
MOVW $490, R12
B callbackasm1(SB)
MOVW $491, R12
B callbackasm1(SB)
MOVW $492, R12
B callbackasm1(SB)
MOVW $493, R12
B callbackasm1(SB)
MOVW $494, R12
B callbackasm1(SB)
MOVW $495, R12
B callbackasm1(SB)
MOVW $496, R12
B callbackasm1(SB)
MOVW $497, R12
B callbackasm1(SB)
MOVW $498, R12
B callbackasm1(SB)
MOVW $499, R12
B callbackasm1(SB)
MOVW $500, R12
B callbackasm1(SB)
MOVW $501, R12
B callbackasm1(SB)
MOVW $502, R12
B callbackasm1(SB)
MOVW $503, R12
B callbackasm1(SB)
MOVW $504, R12
B callbackasm1(SB)
MOVW $505, R12
B callbackasm1(SB)
MOVW $506, R12
B callbackasm1(SB)
MOVW $507, R12
B callbackasm1(SB)
MOVW $508, R12
B callbackasm1(SB)
MOVW $509, R12
B callbackasm1(SB)
MOVW $510, R12
B callbackasm1(SB)
MOVW $511, R12
B callbackasm1(SB)
MOVW $512, R12
B callbackasm1(SB)
MOVW $513, R12
B callbackasm1(SB)
MOVW $514, R12
B callbackasm1(SB)
MOVW $515, R12
B callbackasm1(SB)
MOVW $516, R12
B callbackasm1(SB)
MOVW $517, R12
B callbackasm1(SB)
MOVW $518, R12
B callbackasm1(SB)
MOVW $519, R12
B callbackasm1(SB)
MOVW $520, R12
B callbackasm1(SB)
MOVW $521, R12
B callbackasm1(SB)
MOVW $522, R12
B callbackasm1(SB)
MOVW $523, R12
B callbackasm1(SB)
MOVW $524, R12
B callbackasm1(SB)
MOVW $525, R12
B callbackasm1(SB)
MOVW $526, R12
B callbackasm1(SB)
MOVW $527, R12
B callbackasm1(SB)
MOVW $528, R12
B callbackasm1(SB)
MOVW $529, R12
B callbackasm1(SB)
MOVW $530, R12
B callbackasm1(SB)
MOVW $531, R12
B callbackasm1(SB)
MOVW $532, R12
B callbackasm1(SB)
MOVW $533, R12
B callbackasm1(SB)
MOVW $534, R12
B callbackasm1(SB)
MOVW $535, R12
B callbackasm1(SB)
MOVW $536, R12
B callbackasm1(SB)
MOVW $537, R12
B callbackasm1(SB)
MOVW $538, R12
B callbackasm1(SB)
MOVW $539, R12
B callbackasm1(SB)
MOVW $540, R12
B callbackasm1(SB)
MOVW $541, R12
B callbackasm1(SB)
MOVW $542, R12
B callbackasm1(SB)
MOVW $543, R12
B callbackasm1(SB)
MOVW $544, R12
B callbackasm1(SB)
MOVW $545, R12
B callbackasm1(SB)
MOVW $546, R12
B callbackasm1(SB)
MOVW $547, R12
B callbackasm1(SB)
MOVW $548, R12
B callbackasm1(SB)
MOVW $549, R12
B callbackasm1(SB)
MOVW $550, R12
B callbackasm1(SB)
MOVW $551, R12
B callbackasm1(SB)
MOVW $552, R12
B callbackasm1(SB)
MOVW $553, R12
B callbackasm1(SB)
MOVW $554, R12
B callbackasm1(SB)
MOVW $555, R12
B callbackasm1(SB)
MOVW $556, R12
B callbackasm1(SB)
MOVW $557, R12
B callbackasm1(SB)
MOVW $558, R12
B callbackasm1(SB)
MOVW $559, R12
B callbackasm1(SB)
MOVW $560, R12
B callbackasm1(SB)
MOVW $561, R12
B callbackasm1(SB)
MOVW $562, R12
B callbackasm1(SB)
MOVW $563, R12
B callbackasm1(SB)
MOVW $564, R12
B callbackasm1(SB)
MOVW $565, R12
B callbackasm1(SB)
MOVW $566, R12
B callbackasm1(SB)
MOVW $567, R12
B callbackasm1(SB)
MOVW $568, R12
B callbackasm1(SB)
MOVW $569, R12
B callbackasm1(SB)
MOVW $570, R12
B callbackasm1(SB)
MOVW $571, R12
B callbackasm1(SB)
MOVW $572, R12
B callbackasm1(SB)
MOVW $573, R12
B callbackasm1(SB)
MOVW $574, R12
B callbackasm1(SB)
MOVW $575, R12
B callbackasm1(SB)
MOVW $576, R12
B callbackasm1(SB)
MOVW $577, R12
B callbackasm1(SB)
MOVW $578, R12
B callbackasm1(SB)
MOVW $579, R12
B callbackasm1(SB)
MOVW $580, R12
B callbackasm1(SB)
MOVW $581, R12
B callbackasm1(SB)
MOVW $582, R12
B callbackasm1(SB)
MOVW $583, R12
B callbackasm1(SB)
MOVW $584, R12
B callbackasm1(SB)
MOVW $585, R12
B callbackasm1(SB)
MOVW $586, R12
B callbackasm1(SB)
MOVW $587, R12
B callbackasm1(SB)
MOVW $588, R12
B callbackasm1(SB)
MOVW $589, R12
B callbackasm1(SB)
MOVW $590, R12
B callbackasm1(SB)
MOVW $591, R12
B callbackasm1(SB)
MOVW $592, R12
B callbackasm1(SB)
MOVW $593, R12
B callbackasm1(SB)
MOVW $594, R12
B callbackasm1(SB)
MOVW $595, R12
B callbackasm1(SB)
MOVW $596, R12
B callbackasm1(SB)
MOVW $597, R12
B callbackasm1(SB)
MOVW $598, R12
B callbackasm1(SB)
MOVW $599, R12
B callbackasm1(SB)
MOVW $600, R12
B callbackasm1(SB)
MOVW $601, R12
B callbackasm1(SB)
MOVW $602, R12
B callbackasm1(SB)
MOVW $603, R12
B callbackasm1(SB)
MOVW $604, R12
B callbackasm1(SB)
MOVW $605, R12
B callbackasm1(SB)
MOVW $606, R12
B callbackasm1(SB)
MOVW $607, R12
B callbackasm1(SB)
MOVW $608, R12
B callbackasm1(SB)
MOVW $609, R12
B callbackasm1(SB)
MOVW $610, R12
B callbackasm1(SB)
MOVW $611, R12
B callbackasm1(SB)
MOVW $612, R12
B callbackasm1(SB)
MOVW $613, R12
B callbackasm1(SB)
MOVW $614, R12
B callbackasm1(SB)
MOVW $615, R12
B callbackasm1(SB)
MOVW $616, R12
B callbackasm1(SB)
MOVW $617, R12
B callbackasm1(SB)
MOVW $618, R12
B callbackasm1(SB)
MOVW $619, R12
B callbackasm1(SB)
MOVW $620, R12
B callbackasm1(SB)
MOVW $621, R12
B callbackasm1(SB)
MOVW $622, R12
B callbackasm1(SB)
MOVW $623, R12
B callbackasm1(SB)
MOVW $624, R12
B callbackasm1(SB)
MOVW $625, R12
B callbackasm1(SB)
MOVW $626, R12
B callbackasm1(SB)
MOVW $627, R12
B callbackasm1(SB)
MOVW $628, R12
B callbackasm1(SB)
MOVW $629, R12
B callbackasm1(SB)
MOVW $630, R12
B callbackasm1(SB)
MOVW $631, R12
B callbackasm1(SB)
MOVW $632, R12
B callbackasm1(SB)
MOVW $633, R12
B callbackasm1(SB)
MOVW $634, R12
B callbackasm1(SB)
MOVW $635, R12
B callbackasm1(SB)
MOVW $636, R12
B callbackasm1(SB)
MOVW $637, R12
B callbackasm1(SB)
MOVW $638, R12
B callbackasm1(SB)
MOVW $639, R12
B callbackasm1(SB)
MOVW $640, R12
B callbackasm1(SB)
MOVW $641, R12
B callbackasm1(SB)
MOVW $642, R12
B callbackasm1(SB)
MOVW $643, R12
B callbackasm1(SB)
MOVW $644, R12
B callbackasm1(SB)
MOVW $645, R12
B callbackasm1(SB)
MOVW $646, R12
B callbackasm1(SB)
MOVW $647, R12
B callbackasm1(SB)
MOVW $648, R12
B callbackasm1(SB)
MOVW $649, R12
B callbackasm1(SB)
MOVW $650, R12
B callbackasm1(SB)
MOVW $651, R12
B callbackasm1(SB)
MOVW $652, R12
B callbackasm1(SB)
MOVW $653, R12
B callbackasm1(SB)
MOVW $654, R12
B callbackasm1(SB)
MOVW $655, R12
B callbackasm1(SB)
MOVW $656, R12
B callbackasm1(SB)
MOVW $657, R12
B callbackasm1(SB)
MOVW $658, R12
B callbackasm1(SB)
MOVW $659, R12
B callbackasm1(SB)
MOVW $660, R12
B callbackasm1(SB)
MOVW $661, R12
B callbackasm1(SB)
MOVW $662, R12
B callbackasm1(SB)
MOVW $663, R12
B callbackasm1(SB)
MOVW $664, R12
B callbackasm1(SB)
MOVW $665, R12
B callbackasm1(SB)
MOVW $666, R12
B callbackasm1(SB)
MOVW $667, R12
B callbackasm1(SB)
MOVW $668, R12
B callbackasm1(SB)
MOVW $669, R12
B callbackasm1(SB)
MOVW $670, R12
B callbackasm1(SB)
MOVW $671, R12
B callbackasm1(SB)
MOVW $672, R12
B callbackasm1(SB)
MOVW $673, R12
B callbackasm1(SB)
MOVW $674, R12
B callbackasm1(SB)
MOVW $675, R12
B callbackasm1(SB)
MOVW $676, R12
B callbackasm1(SB)
MOVW $677, R12
B callbackasm1(SB)
MOVW $678, R12
B callbackasm1(SB)
MOVW $679, R12
B callbackasm1(SB)
MOVW $680, R12
B callbackasm1(SB)
MOVW $681, R12
B callbackasm1(SB)
MOVW $682, R12
B callbackasm1(SB)
MOVW $683, R12
B callbackasm1(SB)
MOVW $684, R12
B callbackasm1(SB)
MOVW $685, R12
B callbackasm1(SB)
MOVW $686, R12
B callbackasm1(SB)
MOVW $687, R12
B callbackasm1(SB)
MOVW $688, R12
B callbackasm1(SB)
MOVW $689, R12
B callbackasm1(SB)
MOVW $690, R12
B callbackasm1(SB)
MOVW $691, R12
B callbackasm1(SB)
MOVW $692, R12
B callbackasm1(SB)
MOVW $693, R12
B callbackasm1(SB)
MOVW $694, R12
B callbackasm1(SB)
MOVW $695, R12
B callbackasm1(SB)
MOVW $696, R12
B callbackasm1(SB)
MOVW $697, R12
B callbackasm1(SB)
MOVW $698, R12
B callbackasm1(SB)
MOVW $699, R12
B callbackasm1(SB)
MOVW $700, R12
B callbackasm1(SB)
MOVW $701, R12
B callbackasm1(SB)
MOVW $702, R12
B callbackasm1(SB)
MOVW $703, R12
B callbackasm1(SB)
MOVW $704, R12
B callbackasm1(SB)
MOVW $705, R12
B callbackasm1(SB)
MOVW $706, R12
B callbackasm1(SB)
MOVW $707, R12
B callbackasm1(SB)
MOVW $708, R12
B callbackasm1(SB)
MOVW $709, R12
B callbackasm1(SB)
MOVW $710, R12
B callbackasm1(SB)
MOVW $711, R12
B callbackasm1(SB)
MOVW $712, R12
B callbackasm1(SB)
MOVW $713, R12
B callbackasm1(SB)
MOVW $714, R12
B callbackasm1(SB)
MOVW $715, R12
B callbackasm1(SB)
MOVW $716, R12
B callbackasm1(SB)
MOVW $717, R12
B callbackasm1(SB)
MOVW $718, R12
B callbackasm1(SB)
MOVW $719, R12
B callbackasm1(SB)
MOVW $720, R12
B callbackasm1(SB)
MOVW $721, R12
B callbackasm1(SB)
MOVW $722, R12
B callbackasm1(SB)
MOVW $723, R12
B callbackasm1(SB)
MOVW $724, R12
B callbackasm1(SB)
MOVW $725, R12
B callbackasm1(SB)
MOVW $726, R12
B callbackasm1(SB)
MOVW $727, R12
B callbackasm1(SB)
MOVW $728, R12
B callbackasm1(SB)
MOVW $729, R12
B callbackasm1(SB)
MOVW $730, R12
B callbackasm1(SB)
MOVW $731, R12
B callbackasm1(SB)
MOVW $732, R12
B callbackasm1(SB)
MOVW $733, R12
B callbackasm1(SB)
MOVW $734, R12
B callbackasm1(SB)
MOVW $735, R12
B callbackasm1(SB)
MOVW $736, R12
B callbackasm1(SB)
MOVW $737, R12
B callbackasm1(SB)
MOVW $738, R12
B callbackasm1(SB)
MOVW $739, R12
B callbackasm1(SB)
MOVW $740, R12
B callbackasm1(SB)
MOVW $741, R12
B callbackasm1(SB)
MOVW $742, R12
B callbackasm1(SB)
MOVW $743, R12
B callbackasm1(SB)
MOVW $744, R12
B callbackasm1(SB)
MOVW $745, R12
B callbackasm1(SB)
MOVW $746, R12
B callbackasm1(SB)
MOVW $747, R12
B callbackasm1(SB)
MOVW $748, R12
B callbackasm1(SB)
MOVW $749, R12
B callbackasm1(SB)
MOVW $750, R12
B callbackasm1(SB)
MOVW $751, R12
B callbackasm1(SB)
MOVW $752, R12
B callbackasm1(SB)
MOVW $753, R12
B callbackasm1(SB)
MOVW $754, R12
B callbackasm1(SB)
MOVW $755, R12
B callbackasm1(SB)
MOVW $756, R12
B callbackasm1(SB)
MOVW $757, R12
B callbackasm1(SB)
MOVW $758, R12
B callbackasm1(SB)
MOVW $759, R12
B callbackasm1(SB)
MOVW $760, R12
B callbackasm1(SB)
MOVW $761, R12
B callbackasm1(SB)
MOVW $762, R12
B callbackasm1(SB)
MOVW $763, R12
B callbackasm1(SB)
MOVW $764, R12
B callbackasm1(SB)
MOVW $765, R12
B callbackasm1(SB)
MOVW $766, R12
B callbackasm1(SB)
MOVW $767, R12
B callbackasm1(SB)
MOVW $768, R12
B callbackasm1(SB)
MOVW $769, R12
B callbackasm1(SB)
MOVW $770, R12
B callbackasm1(SB)
MOVW $771, R12
B callbackasm1(SB)
MOVW $772, R12
B callbackasm1(SB)
MOVW $773, R12
B callbackasm1(SB)
MOVW $774, R12
B callbackasm1(SB)
MOVW $775, R12
B callbackasm1(SB)
MOVW $776, R12
B callbackasm1(SB)
MOVW $777, R12
B callbackasm1(SB)
MOVW $778, R12
B callbackasm1(SB)
MOVW $779, R12
B callbackasm1(SB)
MOVW $780, R12
B callbackasm1(SB)
MOVW $781, R12
B callbackasm1(SB)
MOVW $782, R12
B callbackasm1(SB)
MOVW $783, R12
B callbackasm1(SB)
MOVW $784, R12
B callbackasm1(SB)
MOVW $785, R12
B callbackasm1(SB)
MOVW $786, R12
B callbackasm1(SB)
MOVW $787, R12
B callbackasm1(SB)
MOVW $788, R12
B callbackasm1(SB)
MOVW $789, R12
B callbackasm1(SB)
MOVW $790, R12
B callbackasm1(SB)
MOVW $791, R12
B callbackasm1(SB)
MOVW $792, R12
B callbackasm1(SB)
MOVW $793, R12
B callbackasm1(SB)
MOVW $794, R12
B callbackasm1(SB)
MOVW $795, R12
B callbackasm1(SB)
MOVW $796, R12
B callbackasm1(SB)
MOVW $797, R12
B callbackasm1(SB)
MOVW $798, R12
B callbackasm1(SB)
MOVW $799, R12
B callbackasm1(SB)
MOVW $800, R12
B callbackasm1(SB)
MOVW $801, R12
B callbackasm1(SB)
MOVW $802, R12
B callbackasm1(SB)
MOVW $803, R12
B callbackasm1(SB)
MOVW $804, R12
B callbackasm1(SB)
MOVW $805, R12
B callbackasm1(SB)
MOVW $806, R12
B callbackasm1(SB)
MOVW $807, R12
B callbackasm1(SB)
MOVW $808, R12
B callbackasm1(SB)
MOVW $809, R12
B callbackasm1(SB)
MOVW $810, R12
B callbackasm1(SB)
MOVW $811, R12
B callbackasm1(SB)
MOVW $812, R12
B callbackasm1(SB)
MOVW $813, R12
B callbackasm1(SB)
MOVW $814, R12
B callbackasm1(SB)
MOVW $815, R12
B callbackasm1(SB)
MOVW $816, R12
B callbackasm1(SB)
MOVW $817, R12
B callbackasm1(SB)
MOVW $818, R12
B callbackasm1(SB)
MOVW $819, R12
B callbackasm1(SB)
MOVW $820, R12
B callbackasm1(SB)
MOVW $821, R12
B callbackasm1(SB)
MOVW $822, R12
B callbackasm1(SB)
MOVW $823, R12
B callbackasm1(SB)
MOVW $824, R12
B callbackasm1(SB)
MOVW $825, R12
B callbackasm1(SB)
MOVW $826, R12
B callbackasm1(SB)
MOVW $827, R12
B callbackasm1(SB)
MOVW $828, R12
B callbackasm1(SB)
MOVW $829, R12
B callbackasm1(SB)
MOVW $830, R12
B callbackasm1(SB)
MOVW $831, R12
B callbackasm1(SB)
MOVW $832, R12
B callbackasm1(SB)
MOVW $833, R12
B callbackasm1(SB)
MOVW $834, R12
B callbackasm1(SB)
MOVW $835, R12
B callbackasm1(SB)
MOVW $836, R12
B callbackasm1(SB)
MOVW $837, R12
B callbackasm1(SB)
MOVW $838, R12
B callbackasm1(SB)
MOVW $839, R12
B callbackasm1(SB)
MOVW $840, R12
B callbackasm1(SB)
MOVW $841, R12
B callbackasm1(SB)
MOVW $842, R12
B callbackasm1(SB)
MOVW $843, R12
B callbackasm1(SB)
MOVW $844, R12
B callbackasm1(SB)
MOVW $845, R12
B callbackasm1(SB)
MOVW $846, R12
B callbackasm1(SB)
MOVW $847, R12
B callbackasm1(SB)
MOVW $848, R12
B callbackasm1(SB)
MOVW $849, R12
B callbackasm1(SB)
MOVW $850, R12
B callbackasm1(SB)
MOVW $851, R12
B callbackasm1(SB)
MOVW $852, R12
B callbackasm1(SB)
MOVW $853, R12
B callbackasm1(SB)
MOVW $854, R12
B callbackasm1(SB)
MOVW $855, R12
B callbackasm1(SB)
MOVW $856, R12
B callbackasm1(SB)
MOVW $857, R12
B callbackasm1(SB)
MOVW $858, R12
B callbackasm1(SB)
MOVW $859, R12
B callbackasm1(SB)
MOVW $860, R12
B callbackasm1(SB)
MOVW $861, R12
B callbackasm1(SB)
MOVW $862, R12
B callbackasm1(SB)
MOVW $863, R12
B callbackasm1(SB)
MOVW $864, R12
B callbackasm1(SB)
MOVW $865, R12
B callbackasm1(SB)
MOVW $866, R12
B callbackasm1(SB)
MOVW $867, R12
B callbackasm1(SB)
MOVW $868, R12
B callbackasm1(SB)
MOVW $869, R12
B callbackasm1(SB)
MOVW $870, R12
B callbackasm1(SB)
MOVW $871, R12
B callbackasm1(SB)
MOVW $872, R12
B callbackasm1(SB)
MOVW $873, R12
B callbackasm1(SB)
MOVW $874, R12
B callbackasm1(SB)
MOVW $875, R12
B callbackasm1(SB)
MOVW $876, R12
B callbackasm1(SB)
MOVW $877, R12
B callbackasm1(SB)
MOVW $878, R12
B callbackasm1(SB)
MOVW $879, R12
B callbackasm1(SB)
MOVW $880, R12
B callbackasm1(SB)
MOVW $881, R12
B callbackasm1(SB)
MOVW $882, R12
B callbackasm1(SB)
MOVW $883, R12
B callbackasm1(SB)
MOVW $884, R12
B callbackasm1(SB)
MOVW $885, R12
B callbackasm1(SB)
MOVW $886, R12
B callbackasm1(SB)
MOVW $887, R12
B callbackasm1(SB)
MOVW $888, R12
B callbackasm1(SB)
MOVW $889, R12
B callbackasm1(SB)
MOVW $890, R12
B callbackasm1(SB)
MOVW $891, R12
B callbackasm1(SB)
MOVW $892, R12
B callbackasm1(SB)
MOVW $893, R12
B callbackasm1(SB)
MOVW $894, R12
B callbackasm1(SB)
MOVW $895, R12
B callbackasm1(SB)
MOVW $896, R12
B callbackasm1(SB)
MOVW $897, R12
B callbackasm1(SB)
MOVW $898, R12
B callbackasm1(SB)
MOVW $899, R12
B callbackasm1(SB)
MOVW $900, R12
B callbackasm1(SB)
MOVW $901, R12
B callbackasm1(SB)
MOVW $902, R12
B callbackasm1(SB)
MOVW $903, R12
B callbackasm1(SB)
MOVW $904, R12
B callbackasm1(SB)
MOVW $905, R12
B callbackasm1(SB)
MOVW $906, R12
B callbackasm1(SB)
MOVW $907, R12
B callbackasm1(SB)
MOVW $908, R12
B callbackasm1(SB)
MOVW $909, R12
B callbackasm1(SB)
MOVW $910, R12
B callbackasm1(SB)
MOVW $911, R12
B callbackasm1(SB)
MOVW $912, R12
B callbackasm1(SB)
MOVW $913, R12
B callbackasm1(SB)
MOVW $914, R12
B callbackasm1(SB)
MOVW $915, R12
B callbackasm1(SB)
MOVW $916, R12
B callbackasm1(SB)
MOVW $917, R12
B callbackasm1(SB)
MOVW $918, R12
B callbackasm1(SB)
MOVW $919, R12
B callbackasm1(SB)
MOVW $920, R12
B callbackasm1(SB)
MOVW $921, R12
B callbackasm1(SB)
MOVW $922, R12
B callbackasm1(SB)
MOVW $923, R12
B callbackasm1(SB)
MOVW $924, R12
B callbackasm1(SB)
MOVW $925, R12
B callbackasm1(SB)
MOVW $926, R12
B callbackasm1(SB)
MOVW $927, R12
B callbackasm1(SB)
MOVW $928, R12
B callbackasm1(SB)
MOVW $929, R12
B callbackasm1(SB)
MOVW $930, R12
B callbackasm1(SB)
MOVW $931, R12
B callbackasm1(SB)
MOVW $932, R12
B callbackasm1(SB)
MOVW $933, R12
B callbackasm1(SB)
MOVW $934, R12
B callbackasm1(SB)
MOVW $935, R12
B callbackasm1(SB)
MOVW $936, R12
B callbackasm1(SB)
MOVW $937, R12
B callbackasm1(SB)
MOVW $938, R12
B callbackasm1(SB)
MOVW $939, R12
B callbackasm1(SB)
MOVW $940, R12
B callbackasm1(SB)
MOVW $941, R12
B callbackasm1(SB)
MOVW $942, R12
B callbackasm1(SB)
MOVW $943, R12
B callbackasm1(SB)
MOVW $944, R12
B callbackasm1(SB)
MOVW $945, R12
B callbackasm1(SB)
MOVW $946, R12
B callbackasm1(SB)
MOVW $947, R12
B callbackasm1(SB)
MOVW $948, R12
B callbackasm1(SB)
MOVW $949, R12
B callbackasm1(SB)
MOVW $950, R12
B callbackasm1(SB)
MOVW $951, R12
B callbackasm1(SB)
MOVW $952, R12
B callbackasm1(SB)
MOVW $953, R12
B callbackasm1(SB)
MOVW $954, R12
B callbackasm1(SB)
MOVW $955, R12
B callbackasm1(SB)
MOVW $956, R12
B callbackasm1(SB)
MOVW $957, R12
B callbackasm1(SB)
MOVW $958, R12
B callbackasm1(SB)
MOVW $959, R12
B callbackasm1(SB)
MOVW $960, R12
B callbackasm1(SB)
MOVW $961, R12
B callbackasm1(SB)
MOVW $962, R12
B callbackasm1(SB)
MOVW $963, R12
B callbackasm1(SB)
MOVW $964, R12
B callbackasm1(SB)
MOVW $965, R12
B callbackasm1(SB)
MOVW $966, R12
B callbackasm1(SB)
MOVW $967, R12
B callbackasm1(SB)
MOVW $968, R12
B callbackasm1(SB)
MOVW $969, R12
B callbackasm1(SB)
MOVW $970, R12
B callbackasm1(SB)
MOVW $971, R12
B callbackasm1(SB)
MOVW $972, R12
B callbackasm1(SB)
MOVW $973, R12
B callbackasm1(SB)
MOVW $974, R12
B callbackasm1(SB)
MOVW $975, R12
B callbackasm1(SB)
MOVW $976, R12
B callbackasm1(SB)
MOVW $977, R12
B callbackasm1(SB)
MOVW $978, R12
B callbackasm1(SB)
MOVW $979, R12
B callbackasm1(SB)
MOVW $980, R12
B callbackasm1(SB)
MOVW $981, R12
B callbackasm1(SB)
MOVW $982, R12
B callbackasm1(SB)
MOVW $983, R12
B callbackasm1(SB)
MOVW $984, R12
B callbackasm1(SB)
MOVW $985, R12
B callbackasm1(SB)
MOVW $986, R12
B callbackasm1(SB)
MOVW $987, R12
B callbackasm1(SB)
MOVW $988, R12
B callbackasm1(SB)
MOVW $989, R12
B callbackasm1(SB)
MOVW $990, R12
B callbackasm1(SB)
MOVW $991, R12
B callbackasm1(SB)
MOVW $992, R12
B callbackasm1(SB)
MOVW $993, R12
B callbackasm1(SB)
MOVW $994, R12
B callbackasm1(SB)
MOVW $995, R12
B callbackasm1(SB)
MOVW $996, R12
B callbackasm1(SB)
MOVW $997, R12
B callbackasm1(SB)
MOVW $998, R12
B callbackasm1(SB)
MOVW $999, R12
B callbackasm1(SB)
MOVW $1000, R12
B callbackasm1(SB)
MOVW $1001, R12
B callbackasm1(SB)
MOVW $1002, R12
B callbackasm1(SB)
MOVW $1003, R12
B callbackasm1(SB)
MOVW $1004, R12
B callbackasm1(SB)
MOVW $1005, R12
B callbackasm1(SB)
MOVW $1006, R12
B callbackasm1(SB)
MOVW $1007, R12
B callbackasm1(SB)
MOVW $1008, R12
B callbackasm1(SB)
MOVW $1009, R12
B callbackasm1(SB)
MOVW $1010, R12
B callbackasm1(SB)
MOVW $1011, R12
B callbackasm1(SB)
MOVW $1012, R12
B callbackasm1(SB)
MOVW $1013, R12
B callbackasm1(SB)
MOVW $1014, R12
B callbackasm1(SB)
MOVW $1015, R12
B callbackasm1(SB)
MOVW $1016, R12
B callbackasm1(SB)
MOVW $1017, R12
B callbackasm1(SB)
MOVW $1018, R12
B callbackasm1(SB)
MOVW $1019, R12
B callbackasm1(SB)
MOVW $1020, R12
B callbackasm1(SB)
MOVW $1021, R12
B callbackasm1(SB)
MOVW $1022, R12
B callbackasm1(SB)
MOVW $1023, R12
B callbackasm1(SB)
MOVW $1024, R12
B callbackasm1(SB)
MOVW $1025, R12
B callbackasm1(SB)
MOVW $1026, R12
B callbackasm1(SB)
MOVW $1027, R12
B callbackasm1(SB)
MOVW $1028, R12
B callbackasm1(SB)
MOVW $1029, R12
B callbackasm1(SB)
MOVW $1030, R12
B callbackasm1(SB)
MOVW $1031, R12
B callbackasm1(SB)
MOVW $1032, R12
B callbackasm1(SB)
MOVW $1033, R12
B callbackasm1(SB)
MOVW $1034, R12
B callbackasm1(SB)
MOVW $1035, R12
B callbackasm1(SB)
MOVW $1036, R12
B callbackasm1(SB)
MOVW $1037, R12
B callbackasm1(SB)
MOVW $1038, R12
B callbackasm1(SB)
MOVW $1039, R12
B callbackasm1(SB)
MOVW $1040, R12
B callbackasm1(SB)
MOVW $1041, R12
B callbackasm1(SB)
MOVW $1042, R12
B callbackasm1(SB)
MOVW $1043, R12
B callbackasm1(SB)
MOVW $1044, R12
B callbackasm1(SB)
MOVW $1045, R12
B callbackasm1(SB)
MOVW $1046, R12
B callbackasm1(SB)
MOVW $1047, R12
B callbackasm1(SB)
MOVW $1048, R12
B callbackasm1(SB)
MOVW $1049, R12
B callbackasm1(SB)
MOVW $1050, R12
B callbackasm1(SB)
MOVW $1051, R12
B callbackasm1(SB)
MOVW $1052, R12
B callbackasm1(SB)
MOVW $1053, R12
B callbackasm1(SB)
MOVW $1054, R12
B callbackasm1(SB)
MOVW $1055, R12
B callbackasm1(SB)
MOVW $1056, R12
B callbackasm1(SB)
MOVW $1057, R12
B callbackasm1(SB)
MOVW $1058, R12
B callbackasm1(SB)
MOVW $1059, R12
B callbackasm1(SB)
MOVW $1060, R12
B callbackasm1(SB)
MOVW $1061, R12
B callbackasm1(SB)
MOVW $1062, R12
B callbackasm1(SB)
MOVW $1063, R12
B callbackasm1(SB)
MOVW $1064, R12
B callbackasm1(SB)
MOVW $1065, R12
B callbackasm1(SB)
MOVW $1066, R12
B callbackasm1(SB)
MOVW $1067, R12
B callbackasm1(SB)
MOVW $1068, R12
B callbackasm1(SB)
MOVW $1069, R12
B callbackasm1(SB)
MOVW $1070, R12
B callbackasm1(SB)
MOVW $1071, R12
B callbackasm1(SB)
MOVW $1072, R12
B callbackasm1(SB)
MOVW $1073, R12
B callbackasm1(SB)
MOVW $1074, R12
B callbackasm1(SB)
MOVW $1075, R12
B callbackasm1(SB)
MOVW $1076, R12
B callbackasm1(SB)
MOVW $1077, R12
B callbackasm1(SB)
MOVW $1078, R12
B callbackasm1(SB)
MOVW $1079, R12
B callbackasm1(SB)
MOVW $1080, R12
B callbackasm1(SB)
MOVW $1081, R12
B callbackasm1(SB)
MOVW $1082, R12
B callbackasm1(SB)
MOVW $1083, R12
B callbackasm1(SB)
MOVW $1084, R12
B callbackasm1(SB)
MOVW $1085, R12
B callbackasm1(SB)
MOVW $1086, R12
B callbackasm1(SB)
MOVW $1087, R12
B callbackasm1(SB)
MOVW $1088, R12
B callbackasm1(SB)
MOVW $1089, R12
B callbackasm1(SB)
MOVW $1090, R12
B callbackasm1(SB)
MOVW $1091, R12
B callbackasm1(SB)
MOVW $1092, R12
B callbackasm1(SB)
MOVW $1093, R12
B callbackasm1(SB)
MOVW $1094, R12
B callbackasm1(SB)
MOVW $1095, R12
B callbackasm1(SB)
MOVW $1096, R12
B callbackasm1(SB)
MOVW $1097, R12
B callbackasm1(SB)
MOVW $1098, R12
B callbackasm1(SB)
MOVW $1099, R12
B callbackasm1(SB)
MOVW $1100, R12
B callbackasm1(SB)
MOVW $1101, R12
B callbackasm1(SB)
MOVW $1102, R12
B callbackasm1(SB)
MOVW $1103, R12
B callbackasm1(SB)
MOVW $1104, R12
B callbackasm1(SB)
MOVW $1105, R12
B callbackasm1(SB)
MOVW $1106, R12
B callbackasm1(SB)
MOVW $1107, R12
B callbackasm1(SB)
MOVW $1108, R12
B callbackasm1(SB)
MOVW $1109, R12
B callbackasm1(SB)
MOVW $1110, R12
B callbackasm1(SB)
MOVW $1111, R12
B callbackasm1(SB)
MOVW $1112, R12
B callbackasm1(SB)
MOVW $1113, R12
B callbackasm1(SB)
MOVW $1114, R12
B callbackasm1(SB)
MOVW $1115, R12
B callbackasm1(SB)
MOVW $1116, R12
B callbackasm1(SB)
MOVW $1117, R12
B callbackasm1(SB)
MOVW $1118, R12
B callbackasm1(SB)
MOVW $1119, R12
B callbackasm1(SB)
MOVW $1120, R12
B callbackasm1(SB)
MOVW $1121, R12
B callbackasm1(SB)
MOVW $1122, R12
B callbackasm1(SB)
MOVW $1123, R12
B callbackasm1(SB)
MOVW $1124, R12
B callbackasm1(SB)
MOVW $1125, R12
B callbackasm1(SB)
MOVW $1126, R12
B callbackasm1(SB)
MOVW $1127, R12
B callbackasm1(SB)
MOVW $1128, R12
B callbackasm1(SB)
MOVW $1129, R12
B callbackasm1(SB)
MOVW $1130, R12
B callbackasm1(SB)
MOVW $1131, R12
B callbackasm1(SB)
MOVW $1132, R12
B callbackasm1(SB)
MOVW $1133, R12
B callbackasm1(SB)
MOVW $1134, R12
B callbackasm1(SB)
MOVW $1135, R12
B callbackasm1(SB)
MOVW $1136, R12
B callbackasm1(SB)
MOVW $1137, R12
B callbackasm1(SB)
MOVW $1138, R12
B callbackasm1(SB)
MOVW $1139, R12
B callbackasm1(SB)
MOVW $1140, R12
B callbackasm1(SB)
MOVW $1141, R12
B callbackasm1(SB)
MOVW $1142, R12
B callbackasm1(SB)
MOVW $1143, R12
B callbackasm1(SB)
MOVW $1144, R12
B callbackasm1(SB)
MOVW $1145, R12
B callbackasm1(SB)
MOVW $1146, R12
B callbackasm1(SB)
MOVW $1147, R12
B callbackasm1(SB)
MOVW $1148, R12
B callbackasm1(SB)
MOVW $1149, R12
B callbackasm1(SB)
MOVW $1150, R12
B callbackasm1(SB)
MOVW $1151, R12
B callbackasm1(SB)
MOVW $1152, R12
B callbackasm1(SB)
MOVW $1153, R12
B callbackasm1(SB)
MOVW $1154, R12
B callbackasm1(SB)
MOVW $1155, R12
B callbackasm1(SB)
MOVW $1156, R12
B callbackasm1(SB)
MOVW $1157, R12
B callbackasm1(SB)
MOVW $1158, R12
B callbackasm1(SB)
MOVW $1159, R12
B callbackasm1(SB)
MOVW $1160, R12
B callbackasm1(SB)
MOVW $1161, R12
B callbackasm1(SB)
MOVW $1162, R12
B callbackasm1(SB)
MOVW $1163, R12
B callbackasm1(SB)
MOVW $1164, R12
B callbackasm1(SB)
MOVW $1165, R12
B callbackasm1(SB)
MOVW $1166, R12
B callbackasm1(SB)
MOVW $1167, R12
B callbackasm1(SB)
MOVW $1168, R12
B callbackasm1(SB)
MOVW $1169, R12
B callbackasm1(SB)
MOVW $1170, R12
B callbackasm1(SB)
MOVW $1171, R12
B callbackasm1(SB)
MOVW $1172, R12
B callbackasm1(SB)
MOVW $1173, R12
B callbackasm1(SB)
MOVW $1174, R12
B callbackasm1(SB)
MOVW $1175, R12
B callbackasm1(SB)
MOVW $1176, R12
B callbackasm1(SB)
MOVW $1177, R12
B callbackasm1(SB)
MOVW $1178, R12
B callbackasm1(SB)
MOVW $1179, R12
B callbackasm1(SB)
MOVW $1180, R12
B callbackasm1(SB)
MOVW $1181, R12
B callbackasm1(SB)
MOVW $1182, R12
B callbackasm1(SB)
MOVW $1183, R12
B callbackasm1(SB)
MOVW $1184, R12
B callbackasm1(SB)
MOVW $1185, R12
B callbackasm1(SB)
MOVW $1186, R12
B callbackasm1(SB)
MOVW $1187, R12
B callbackasm1(SB)
MOVW $1188, R12
B callbackasm1(SB)
MOVW $1189, R12
B callbackasm1(SB)
MOVW $1190, R12
B callbackasm1(SB)
MOVW $1191, R12
B callbackasm1(SB)
MOVW $1192, R12
B callbackasm1(SB)
MOVW $1193, R12
B callbackasm1(SB)
MOVW $1194, R12
B callbackasm1(SB)
MOVW $1195, R12
B callbackasm1(SB)
MOVW $1196, R12
B callbackasm1(SB)
MOVW $1197, R12
B callbackasm1(SB)
MOVW $1198, R12
B callbackasm1(SB)
MOVW $1199, R12
B callbackasm1(SB)
MOVW $1200, R12
B callbackasm1(SB)
MOVW $1201, R12
B callbackasm1(SB)
MOVW $1202, R12
B callbackasm1(SB)
MOVW $1203, R12
B callbackasm1(SB)
MOVW $1204, R12
B callbackasm1(SB)
MOVW $1205, R12
B callbackasm1(SB)
MOVW $1206, R12
B callbackasm1(SB)
MOVW $1207, R12
B callbackasm1(SB)
MOVW $1208, R12
B callbackasm1(SB)
MOVW $1209, R12
B callbackasm1(SB)
MOVW $1210, R12
B callbackasm1(SB)
MOVW $1211, R12
B callbackasm1(SB)
MOVW $1212, R12
B callbackasm1(SB)
MOVW $1213, R12
B callbackasm1(SB)
MOVW $1214, R12
B callbackasm1(SB)
MOVW $1215, R12
B callbackasm1(SB)
MOVW $1216, R12
B callbackasm1(SB)
MOVW $1217, R12
B callbackasm1(SB)
MOVW $1218, R12
B callbackasm1(SB)
MOVW $1219, R12
B callbackasm1(SB)
MOVW $1220, R12
B callbackasm1(SB)
MOVW $1221, R12
B callbackasm1(SB)
MOVW $1222, R12
B callbackasm1(SB)
MOVW $1223, R12
B callbackasm1(SB)
MOVW $1224, R12
B callbackasm1(SB)
MOVW $1225, R12
B callbackasm1(SB)
MOVW $1226, R12
B callbackasm1(SB)
MOVW $1227, R12
B callbackasm1(SB)
MOVW $1228, R12
B callbackasm1(SB)
MOVW $1229, R12
B callbackasm1(SB)
MOVW $1230, R12
B callbackasm1(SB)
MOVW $1231, R12
B callbackasm1(SB)
MOVW $1232, R12
B callbackasm1(SB)
MOVW $1233, R12
B callbackasm1(SB)
MOVW $1234, R12
B callbackasm1(SB)
MOVW $1235, R12
B callbackasm1(SB)
MOVW $1236, R12
B callbackasm1(SB)
MOVW $1237, R12
B callbackasm1(SB)
MOVW $1238, R12
B callbackasm1(SB)
MOVW $1239, R12
B callbackasm1(SB)
MOVW $1240, R12
B callbackasm1(SB)
MOVW $1241, R12
B callbackasm1(SB)
MOVW $1242, R12
B callbackasm1(SB)
MOVW $1243, R12
B callbackasm1(SB)
MOVW $1244, R12
B callbackasm1(SB)
MOVW $1245, R12
B callbackasm1(SB)
MOVW $1246, R12
B callbackasm1(SB)
MOVW $1247, R12
B callbackasm1(SB)
MOVW $1248, R12
B callbackasm1(SB)
MOVW $1249, R12
B callbackasm1(SB)
MOVW $1250, R12
B callbackasm1(SB)
MOVW $1251, R12
B callbackasm1(SB)
MOVW $1252, R12
B callbackasm1(SB)
MOVW $1253, R12
B callbackasm1(SB)
MOVW $1254, R12
B callbackasm1(SB)
MOVW $1255, R12
B callbackasm1(SB)
MOVW $1256, R12
B callbackasm1(SB)
MOVW $1257, R12
B callbackasm1(SB)
MOVW $1258, R12
B callbackasm1(SB)
MOVW $1259, R12
B callbackasm1(SB)
MOVW $1260, R12
B callbackasm1(SB)
MOVW $1261, R12
B callbackasm1(SB)
MOVW $1262, R12
B callbackasm1(SB)
MOVW $1263, R12
B callbackasm1(SB)
MOVW $1264, R12
B callbackasm1(SB)
MOVW $1265, R12
B callbackasm1(SB)
MOVW $1266, R12
B callbackasm1(SB)
MOVW $1267, R12
B callbackasm1(SB)
MOVW $1268, R12
B callbackasm1(SB)
MOVW $1269, R12
B callbackasm1(SB)
MOVW $1270, R12
B callbackasm1(SB)
MOVW $1271, R12
B callbackasm1(SB)
MOVW $1272, R12
B callbackasm1(SB)
MOVW $1273, R12
B callbackasm1(SB)
MOVW $1274, R12
B callbackasm1(SB)
MOVW $1275, R12
B callbackasm1(SB)
MOVW $1276, R12
B callbackasm1(SB)
MOVW $1277, R12
B callbackasm1(SB)
MOVW $1278, R12
B callbackasm1(SB)
MOVW $1279, R12
B callbackasm1(SB)
MOVW $1280, R12
B callbackasm1(SB)
MOVW $1281, R12
B callbackasm1(SB)
MOVW $1282, R12
B callbackasm1(SB)
MOVW $1283, R12
B callbackasm1(SB)
MOVW $1284, R12
B callbackasm1(SB)
MOVW $1285, R12
B callbackasm1(SB)
MOVW $1286, R12
B callbackasm1(SB)
MOVW $1287, R12
B callbackasm1(SB)
MOVW $1288, R12
B callbackasm1(SB)
MOVW $1289, R12
B callbackasm1(SB)
MOVW $1290, R12
B callbackasm1(SB)
MOVW $1291, R12
B callbackasm1(SB)
MOVW $1292, R12
B callbackasm1(SB)
MOVW $1293, R12
B callbackasm1(SB)
MOVW $1294, R12
B callbackasm1(SB)
MOVW $1295, R12
B callbackasm1(SB)
MOVW $1296, R12
B callbackasm1(SB)
MOVW $1297, R12
B callbackasm1(SB)
MOVW $1298, R12
B callbackasm1(SB)
MOVW $1299, R12
B callbackasm1(SB)
MOVW $1300, R12
B callbackasm1(SB)
MOVW $1301, R12
B callbackasm1(SB)
MOVW $1302, R12
B callbackasm1(SB)
MOVW $1303, R12
B callbackasm1(SB)
MOVW $1304, R12
B callbackasm1(SB)
MOVW $1305, R12
B callbackasm1(SB)
MOVW $1306, R12
B callbackasm1(SB)
MOVW $1307, R12
B callbackasm1(SB)
MOVW $1308, R12
B callbackasm1(SB)
MOVW $1309, R12
B callbackasm1(SB)
MOVW $1310, R12
B callbackasm1(SB)
MOVW $1311, R12
B callbackasm1(SB)
MOVW $1312, R12
B callbackasm1(SB)
MOVW $1313, R12
B callbackasm1(SB)
MOVW $1314, R12
B callbackasm1(SB)
MOVW $1315, R12
B callbackasm1(SB)
MOVW $1316, R12
B callbackasm1(SB)
MOVW $1317, R12
B callbackasm1(SB)
MOVW $1318, R12
B callbackasm1(SB)
MOVW $1319, R12
B callbackasm1(SB)
MOVW $1320, R12
B callbackasm1(SB)
MOVW $1321, R12
B callbackasm1(SB)
MOVW $1322, R12
B callbackasm1(SB)
MOVW $1323, R12
B callbackasm1(SB)
MOVW $1324, R12
B callbackasm1(SB)
MOVW $1325, R12
B callbackasm1(SB)
MOVW $1326, R12
B callbackasm1(SB)
MOVW $1327, R12
B callbackasm1(SB)
MOVW $1328, R12
B callbackasm1(SB)
MOVW $1329, R12
B callbackasm1(SB)
MOVW $1330, R12
B callbackasm1(SB)
MOVW $1331, R12
B callbackasm1(SB)
MOVW $1332, R12
B callbackasm1(SB)
MOVW $1333, R12
B callbackasm1(SB)
MOVW $1334, R12
B callbackasm1(SB)
MOVW $1335, R12
B callbackasm1(SB)
MOVW $1336, R12
B callbackasm1(SB)
MOVW $1337, R12
B callbackasm1(SB)
MOVW $1338, R12
B callbackasm1(SB)
MOVW $1339, R12
B callbackasm1(SB)
MOVW $1340, R12
B callbackasm1(SB)
MOVW $1341, R12
B callbackasm1(SB)
MOVW $1342, R12
B callbackasm1(SB)
MOVW $1343, R12
B callbackasm1(SB)
MOVW $1344, R12
B callbackasm1(SB)
MOVW $1345, R12
B callbackasm1(SB)
MOVW $1346, R12
B callbackasm1(SB)
MOVW $1347, R12
B callbackasm1(SB)
MOVW $1348, R12
B callbackasm1(SB)
MOVW $1349, R12
B callbackasm1(SB)
MOVW $1350, R12
B callbackasm1(SB)
MOVW $1351, R12
B callbackasm1(SB)
MOVW $1352, R12
B callbackasm1(SB)
MOVW $1353, R12
B callbackasm1(SB)
MOVW $1354, R12
B callbackasm1(SB)
MOVW $1355, R12
B callbackasm1(SB)
MOVW $1356, R12
B callbackasm1(SB)
MOVW $1357, R12
B callbackasm1(SB)
MOVW $1358, R12
B callbackasm1(SB)
MOVW $1359, R12
B callbackasm1(SB)
MOVW $1360, R12
B callbackasm1(SB)
MOVW $1361, R12
B callbackasm1(SB)
MOVW $1362, R12
B callbackasm1(SB)
MOVW $1363, R12
B callbackasm1(SB)
MOVW $1364, R12
B callbackasm1(SB)
MOVW $1365, R12
B callbackasm1(SB)
MOVW $1366, R12
B callbackasm1(SB)
MOVW $1367, R12
B callbackasm1(SB)
MOVW $1368, R12
B callbackasm1(SB)
MOVW $1369, R12
B callbackasm1(SB)
MOVW $1370, R12
B callbackasm1(SB)
MOVW $1371, R12
B callbackasm1(SB)
MOVW $1372, R12
B callbackasm1(SB)
MOVW $1373, R12
B callbackasm1(SB)
MOVW $1374, R12
B callbackasm1(SB)
MOVW $1375, R12
B callbackasm1(SB)
MOVW $1376, R12
B callbackasm1(SB)
MOVW $1377, R12
B callbackasm1(SB)
MOVW $1378, R12
B callbackasm1(SB)
MOVW $1379, R12
B callbackasm1(SB)
MOVW $1380, R12
B callbackasm1(SB)
MOVW $1381, R12
B callbackasm1(SB)
MOVW $1382, R12
B callbackasm1(SB)
MOVW $1383, R12
B callbackasm1(SB)
MOVW $1384, R12
B callbackasm1(SB)
MOVW $1385, R12
B callbackasm1(SB)
MOVW $1386, R12
B callbackasm1(SB)
MOVW $1387, R12
B callbackasm1(SB)
MOVW $1388, R12
B callbackasm1(SB)
MOVW $1389, R12
B callbackasm1(SB)
MOVW $1390, R12
B callbackasm1(SB)
MOVW $1391, R12
B callbackasm1(SB)
MOVW $1392, R12
B callbackasm1(SB)
MOVW $1393, R12
B callbackasm1(SB)
MOVW $1394, R12
B callbackasm1(SB)
MOVW $1395, R12
B callbackasm1(SB)
MOVW $1396, R12
B callbackasm1(SB)
MOVW $1397, R12
B callbackasm1(SB)
MOVW $1398, R12
B callbackasm1(SB)
MOVW $1399, R12
B callbackasm1(SB)
MOVW $1400, R12
B callbackasm1(SB)
MOVW $1401, R12
B callbackasm1(SB)
MOVW $1402, R12
B callbackasm1(SB)
MOVW $1403, R12
B callbackasm1(SB)
MOVW $1404, R12
B callbackasm1(SB)
MOVW $1405, R12
B callbackasm1(SB)
MOVW $1406, R12
B callbackasm1(SB)
MOVW $1407, R12
B callbackasm1(SB)
MOVW $1408, R12
B callbackasm1(SB)
MOVW $1409, R12
B callbackasm1(SB)
MOVW $1410, R12
B callbackasm1(SB)
MOVW $1411, R12
B callbackasm1(SB)
MOVW $1412, R12
B callbackasm1(SB)
MOVW $1413, R12
B callbackasm1(SB)
MOVW $1414, R12
B callbackasm1(SB)
MOVW $1415, R12
B callbackasm1(SB)
MOVW $1416, R12
B callbackasm1(SB)
MOVW $1417, R12
B callbackasm1(SB)
MOVW $1418, R12
B callbackasm1(SB)
MOVW $1419, R12
B callbackasm1(SB)
MOVW $1420, R12
B callbackasm1(SB)
MOVW $1421, R12
B callbackasm1(SB)
MOVW $1422, R12
B callbackasm1(SB)
MOVW $1423, R12
B callbackasm1(SB)
MOVW $1424, R12
B callbackasm1(SB)
MOVW $1425, R12
B callbackasm1(SB)
MOVW $1426, R12
B callbackasm1(SB)
MOVW $1427, R12
B callbackasm1(SB)
MOVW $1428, R12
B callbackasm1(SB)
MOVW $1429, R12
B callbackasm1(SB)
MOVW $1430, R12
B callbackasm1(SB)
MOVW $1431, R12
B callbackasm1(SB)
MOVW $1432, R12
B callbackasm1(SB)
MOVW $1433, R12
B callbackasm1(SB)
MOVW $1434, R12
B callbackasm1(SB)
MOVW $1435, R12
B callbackasm1(SB)
MOVW $1436, R12
B callbackasm1(SB)
MOVW $1437, R12
B callbackasm1(SB)
MOVW $1438, R12
B callbackasm1(SB)
MOVW $1439, R12
B callbackasm1(SB)
MOVW $1440, R12
B callbackasm1(SB)
MOVW $1441, R12
B callbackasm1(SB)
MOVW $1442, R12
B callbackasm1(SB)
MOVW $1443, R12
B callbackasm1(SB)
MOVW $1444, R12
B callbackasm1(SB)
MOVW $1445, R12
B callbackasm1(SB)
MOVW $1446, R12
B callbackasm1(SB)
MOVW $1447, R12
B callbackasm1(SB)
MOVW $1448, R12
B callbackasm1(SB)
MOVW $1449, R12
B callbackasm1(SB)
MOVW $1450, R12
B callbackasm1(SB)
MOVW $1451, R12
B callbackasm1(SB)
MOVW $1452, R12
B callbackasm1(SB)
MOVW $1453, R12
B callbackasm1(SB)
MOVW $1454, R12
B callbackasm1(SB)
MOVW $1455, R12
B callbackasm1(SB)
MOVW $1456, R12
B callbackasm1(SB)
MOVW $1457, R12
B callbackasm1(SB)
MOVW $1458, R12
B callbackasm1(SB)
MOVW $1459, R12
B callbackasm1(SB)
MOVW $1460, R12
B callbackasm1(SB)
MOVW $1461, R12
B callbackasm1(SB)
MOVW $1462, R12
B callbackasm1(SB)
MOVW $1463, R12
B callbackasm1(SB)
MOVW $1464, R12
B callbackasm1(SB)
MOVW $1465, R12
B callbackasm1(SB)
MOVW $1466, R12
B callbackasm1(SB)
MOVW $1467, R12
B callbackasm1(SB)
MOVW $1468, R12
B callbackasm1(SB)
MOVW $1469, R12
B callbackasm1(SB)
MOVW $1470, R12
B callbackasm1(SB)
MOVW $1471, R12
B callbackasm1(SB)
MOVW $1472, R12
B callbackasm1(SB)
MOVW $1473, R12
B callbackasm1(SB)
MOVW $1474, R12
B callbackasm1(SB)
MOVW $1475, R12
B callbackasm1(SB)
MOVW $1476, R12
B callbackasm1(SB)
MOVW $1477, R12
B callbackasm1(SB)
MOVW $1478, R12
B callbackasm1(SB)
MOVW $1479, R12
B callbackasm1(SB)
MOVW $1480, R12
B callbackasm1(SB)
MOVW $1481, R12
B callbackasm1(SB)
MOVW $1482, R12
B callbackasm1(SB)
MOVW $1483, R12
B callbackasm1(SB)
MOVW $1484, R12
B callbackasm1(SB)
MOVW $1485, R12
B callbackasm1(SB)
MOVW $1486, R12
B callbackasm1(SB)
MOVW $1487, R12
B callbackasm1(SB)
MOVW $1488, R12
B callbackasm1(SB)
MOVW $1489, R12
B callbackasm1(SB)
MOVW $1490, R12
B callbackasm1(SB)
MOVW $1491, R12
B callbackasm1(SB)
MOVW $1492, R12
B callbackasm1(SB)
MOVW $1493, R12
B callbackasm1(SB)
MOVW $1494, R12
B callbackasm1(SB)
MOVW $1495, R12
B callbackasm1(SB)
MOVW $1496, R12
B callbackasm1(SB)
MOVW $1497, R12
B callbackasm1(SB)
MOVW $1498, R12
B callbackasm1(SB)
MOVW $1499, R12
B callbackasm1(SB)
MOVW $1500, R12
B callbackasm1(SB)
MOVW $1501, R12
B callbackasm1(SB)
MOVW $1502, R12
B callbackasm1(SB)
MOVW $1503, R12
B callbackasm1(SB)
MOVW $1504, R12
B callbackasm1(SB)
MOVW $1505, R12
B callbackasm1(SB)
MOVW $1506, R12
B callbackasm1(SB)
MOVW $1507, R12
B callbackasm1(SB)
MOVW $1508, R12
B callbackasm1(SB)
MOVW $1509, R12
B callbackasm1(SB)
MOVW $1510, R12
B callbackasm1(SB)
MOVW $1511, R12
B callbackasm1(SB)
MOVW $1512, R12
B callbackasm1(SB)
MOVW $1513, R12
B callbackasm1(SB)
MOVW $1514, R12
B callbackasm1(SB)
MOVW $1515, R12
B callbackasm1(SB)
MOVW $1516, R12
B callbackasm1(SB)
MOVW $1517, R12
B callbackasm1(SB)
MOVW $1518, R12
B callbackasm1(SB)
MOVW $1519, R12
B callbackasm1(SB)
MOVW $1520, R12
B callbackasm1(SB)
MOVW $1521, R12
B callbackasm1(SB)
MOVW $1522, R12
B callbackasm1(SB)
MOVW $1523, R12
B callbackasm1(SB)
MOVW $1524, R12
B callbackasm1(SB)
MOVW $1525, R12
B callbackasm1(SB)
MOVW $1526, R12
B callbackasm1(SB)
MOVW $1527, R12
B callbackasm1(SB)
MOVW $1528, R12
B callbackasm1(SB)
MOVW $1529, R12
B callbackasm1(SB)
MOVW $1530, R12
B callbackasm1(SB)
MOVW $1531, R12
B callbackasm1(SB)
MOVW $1532, R12
B callbackasm1(SB)
MOVW $1533, R12
B callbackasm1(SB)
MOVW $1534, R12
B callbackasm1(SB)
MOVW $1535, R12
B callbackasm1(SB)
MOVW $1536, R12
B callbackasm1(SB)
MOVW $1537, R12
B callbackasm1(SB)
MOVW $1538, R12
B callbackasm1(SB)
MOVW $1539, R12
B callbackasm1(SB)
MOVW $1540, R12
B callbackasm1(SB)
MOVW $1541, R12
B callbackasm1(SB)
MOVW $1542, R12
B callbackasm1(SB)
MOVW $1543, R12
B callbackasm1(SB)
MOVW $1544, R12
B callbackasm1(SB)
MOVW $1545, R12
B callbackasm1(SB)
MOVW $1546, R12
B callbackasm1(SB)
MOVW $1547, R12
B callbackasm1(SB)
MOVW $1548, R12
B callbackasm1(SB)
MOVW $1549, R12
B callbackasm1(SB)
MOVW $1550, R12
B callbackasm1(SB)
MOVW $1551, R12
B callbackasm1(SB)
MOVW $1552, R12
B callbackasm1(SB)
MOVW $1553, R12
B callbackasm1(SB)
MOVW $1554, R12
B callbackasm1(SB)
MOVW $1555, R12
B callbackasm1(SB)
MOVW $1556, R12
B callbackasm1(SB)
MOVW $1557, R12
B callbackasm1(SB)
MOVW $1558, R12
B callbackasm1(SB)
MOVW $1559, R12
B callbackasm1(SB)
MOVW $1560, R12
B callbackasm1(SB)
MOVW $1561, R12
B callbackasm1(SB)
MOVW $1562, R12
B callbackasm1(SB)
MOVW $1563, R12
B callbackasm1(SB)
MOVW $1564, R12
B callbackasm1(SB)
MOVW $1565, R12
B callbackasm1(SB)
MOVW $1566, R12
B callbackasm1(SB)
MOVW $1567, R12
B callbackasm1(SB)
MOVW $1568, R12
B callbackasm1(SB)
MOVW $1569, R12
B callbackasm1(SB)
MOVW $1570, R12
B callbackasm1(SB)
MOVW $1571, R12
B callbackasm1(SB)
MOVW $1572, R12
B callbackasm1(SB)
MOVW $1573, R12
B callbackasm1(SB)
MOVW $1574, R12
B callbackasm1(SB)
MOVW $1575, R12
B callbackasm1(SB)
MOVW $1576, R12
B callbackasm1(SB)
MOVW $1577, R12
B callbackasm1(SB)
MOVW $1578, R12
B callbackasm1(SB)
MOVW $1579, R12
B callbackasm1(SB)
MOVW $1580, R12
B callbackasm1(SB)
MOVW $1581, R12
B callbackasm1(SB)
MOVW $1582, R12
B callbackasm1(SB)
MOVW $1583, R12
B callbackasm1(SB)
MOVW $1584, R12
B callbackasm1(SB)
MOVW $1585, R12
B callbackasm1(SB)
MOVW $1586, R12
B callbackasm1(SB)
MOVW $1587, R12
B callbackasm1(SB)
MOVW $1588, R12
B callbackasm1(SB)
MOVW $1589, R12
B callbackasm1(SB)
MOVW $1590, R12
B callbackasm1(SB)
MOVW $1591, R12
B callbackasm1(SB)
MOVW $1592, R12
B callbackasm1(SB)
MOVW $1593, R12
B callbackasm1(SB)
MOVW $1594, R12
B callbackasm1(SB)
MOVW $1595, R12
B callbackasm1(SB)
MOVW $1596, R12
B callbackasm1(SB)
MOVW $1597, R12
B callbackasm1(SB)
MOVW $1598, R12
B callbackasm1(SB)
MOVW $1599, R12
B callbackasm1(SB)
MOVW $1600, R12
B callbackasm1(SB)
MOVW $1601, R12
B callbackasm1(SB)
MOVW $1602, R12
B callbackasm1(SB)
MOVW $1603, R12
B callbackasm1(SB)
MOVW $1604, R12
B callbackasm1(SB)
MOVW $1605, R12
B callbackasm1(SB)
MOVW $1606, R12
B callbackasm1(SB)
MOVW $1607, R12
B callbackasm1(SB)
MOVW $1608, R12
B callbackasm1(SB)
MOVW $1609, R12
B callbackasm1(SB)
MOVW $1610, R12
B callbackasm1(SB)
MOVW $1611, R12
B callbackasm1(SB)
MOVW $1612, R12
B callbackasm1(SB)
MOVW $1613, R12
B callbackasm1(SB)
MOVW $1614, R12
B callbackasm1(SB)
MOVW $1615, R12
B callbackasm1(SB)
MOVW $1616, R12
B callbackasm1(SB)
MOVW $1617, R12
B callbackasm1(SB)
MOVW $1618, R12
B callbackasm1(SB)
MOVW $1619, R12
B callbackasm1(SB)
MOVW $1620, R12
B callbackasm1(SB)
MOVW $1621, R12
B callbackasm1(SB)
MOVW $1622, R12
B callbackasm1(SB)
MOVW $1623, R12
B callbackasm1(SB)
MOVW $1624, R12
B callbackasm1(SB)
MOVW $1625, R12
B callbackasm1(SB)
MOVW $1626, R12
B callbackasm1(SB)
MOVW $1627, R12
B callbackasm1(SB)
MOVW $1628, R12
B callbackasm1(SB)
MOVW $1629, R12
B callbackasm1(SB)
MOVW $1630, R12
B callbackasm1(SB)
MOVW $1631, R12
B callbackasm1(SB)
MOVW $1632, R12
B callbackasm1(SB)
MOVW $1633, R12
B callbackasm1(SB)
MOVW $1634, R12
B callbackasm1(SB)
MOVW $1635, R12
B callbackasm1(SB)
MOVW $1636, R12
B callbackasm1(SB)
MOVW $1637, R12
B callbackasm1(SB)
MOVW $1638, R12
B callbackasm1(SB)
MOVW $1639, R12
B callbackasm1(SB)
MOVW $1640, R12
B callbackasm1(SB)
MOVW $1641, R12
B callbackasm1(SB)
MOVW $1642, R12
B callbackasm1(SB)
MOVW $1643, R12
B callbackasm1(SB)
MOVW $1644, R12
B callbackasm1(SB)
MOVW $1645, R12
B callbackasm1(SB)
MOVW $1646, R12
B callbackasm1(SB)
MOVW $1647, R12
B callbackasm1(SB)
MOVW $1648, R12
B callbackasm1(SB)
MOVW $1649, R12
B callbackasm1(SB)
MOVW $1650, R12
B callbackasm1(SB)
MOVW $1651, R12
B callbackasm1(SB)
MOVW $1652, R12
B callbackasm1(SB)
MOVW $1653, R12
B callbackasm1(SB)
MOVW $1654, R12
B callbackasm1(SB)
MOVW $1655, R12
B callbackasm1(SB)
MOVW $1656, R12
B callbackasm1(SB)
MOVW $1657, R12
B callbackasm1(SB)
MOVW $1658, R12
B callbackasm1(SB)
MOVW $1659, R12
B callbackasm1(SB)
MOVW $1660, R12
B callbackasm1(SB)
MOVW $1661, R12
B callbackasm1(SB)
MOVW $1662, R12
B callbackasm1(SB)
MOVW $1663, R12
B callbackasm1(SB)
MOVW $1664, R12
B callbackasm1(SB)
MOVW $1665, R12
B callbackasm1(SB)
MOVW $1666, R12
B callbackasm1(SB)
MOVW $1667, R12
B callbackasm1(SB)
MOVW $1668, R12
B callbackasm1(SB)
MOVW $1669, R12
B callbackasm1(SB)
MOVW $1670, R12
B callbackasm1(SB)
MOVW $1671, R12
B callbackasm1(SB)
MOVW $1672, R12
B callbackasm1(SB)
MOVW $1673, R12
B callbackasm1(SB)
MOVW $1674, R12
B callbackasm1(SB)
MOVW $1675, R12
B callbackasm1(SB)
MOVW $1676, R12
B callbackasm1(SB)
MOVW $1677, R12
B callbackasm1(SB)
MOVW $1678, R12
B callbackasm1(SB)
MOVW $1679, R12
B callbackasm1(SB)
MOVW $1680, R12
B callbackasm1(SB)
MOVW $1681, R12
B callbackasm1(SB)
MOVW $1682, R12
B callbackasm1(SB)
MOVW $1683, R12
B callbackasm1(SB)
MOVW $1684, R12
B callbackasm1(SB)
MOVW $1685, R12
B callbackasm1(SB)
MOVW $1686, R12
B callbackasm1(SB)
MOVW $1687, R12
B callbackasm1(SB)
MOVW $1688, R12
B callbackasm1(SB)
MOVW $1689, R12
B callbackasm1(SB)
MOVW $1690, R12
B callbackasm1(SB)
MOVW $1691, R12
B callbackasm1(SB)
MOVW $1692, R12
B callbackasm1(SB)
MOVW $1693, R12
B callbackasm1(SB)
MOVW $1694, R12
B callbackasm1(SB)
MOVW $1695, R12
B callbackasm1(SB)
MOVW $1696, R12
B callbackasm1(SB)
MOVW $1697, R12
B callbackasm1(SB)
MOVW $1698, R12
B callbackasm1(SB)
MOVW $1699, R12
B callbackasm1(SB)
MOVW $1700, R12
B callbackasm1(SB)
MOVW $1701, R12
B callbackasm1(SB)
MOVW $1702, R12
B callbackasm1(SB)
MOVW $1703, R12
B callbackasm1(SB)
MOVW $1704, R12
B callbackasm1(SB)
MOVW $1705, R12
B callbackasm1(SB)
MOVW $1706, R12
B callbackasm1(SB)
MOVW $1707, R12
B callbackasm1(SB)
MOVW $1708, R12
B callbackasm1(SB)
MOVW $1709, R12
B callbackasm1(SB)
MOVW $1710, R12
B callbackasm1(SB)
MOVW $1711, R12
B callbackasm1(SB)
MOVW $1712, R12
B callbackasm1(SB)
MOVW $1713, R12
B callbackasm1(SB)
MOVW $1714, R12
B callbackasm1(SB)
MOVW $1715, R12
B callbackasm1(SB)
MOVW $1716, R12
B callbackasm1(SB)
MOVW $1717, R12
B callbackasm1(SB)
MOVW $1718, R12
B callbackasm1(SB)
MOVW $1719, R12
B callbackasm1(SB)
MOVW $1720, R12
B callbackasm1(SB)
MOVW $1721, R12
B callbackasm1(SB)
MOVW $1722, R12
B callbackasm1(SB)
MOVW $1723, R12
B callbackasm1(SB)
MOVW $1724, R12
B callbackasm1(SB)
MOVW $1725, R12
B callbackasm1(SB)
MOVW $1726, R12
B callbackasm1(SB)
MOVW $1727, R12
B callbackasm1(SB)
MOVW $1728, R12
B callbackasm1(SB)
MOVW $1729, R12
B callbackasm1(SB)
MOVW $1730, R12
B callbackasm1(SB)
MOVW $1731, R12
B callbackasm1(SB)
MOVW $1732, R12
B callbackasm1(SB)
MOVW $1733, R12
B callbackasm1(SB)
MOVW $1734, R12
B callbackasm1(SB)
MOVW $1735, R12
B callbackasm1(SB)
MOVW $1736, R12
B callbackasm1(SB)
MOVW $1737, R12
B callbackasm1(SB)
MOVW $1738, R12
B callbackasm1(SB)
MOVW $1739, R12
B callbackasm1(SB)
MOVW $1740, R12
B callbackasm1(SB)
MOVW $1741, R12
B callbackasm1(SB)
MOVW $1742, R12
B callbackasm1(SB)
MOVW $1743, R12
B callbackasm1(SB)
MOVW $1744, R12
B callbackasm1(SB)
MOVW $1745, R12
B callbackasm1(SB)
MOVW $1746, R12
B callbackasm1(SB)
MOVW $1747, R12
B callbackasm1(SB)
MOVW $1748, R12
B callbackasm1(SB)
MOVW $1749, R12
B callbackasm1(SB)
MOVW $1750, R12
B callbackasm1(SB)
MOVW $1751, R12
B callbackasm1(SB)
MOVW $1752, R12
B callbackasm1(SB)
MOVW $1753, R12
B callbackasm1(SB)
MOVW $1754, R12
B callbackasm1(SB)
MOVW $1755, R12
B callbackasm1(SB)
MOVW $1756, R12
B callbackasm1(SB)
MOVW $1757, R12
B callbackasm1(SB)
MOVW $1758, R12
B callbackasm1(SB)
MOVW $1759, R12
B callbackasm1(SB)
MOVW $1760, R12
B callbackasm1(SB)
MOVW $1761, R12
B callbackasm1(SB)
MOVW $1762, R12
B callbackasm1(SB)
MOVW $1763, R12
B callbackasm1(SB)
MOVW $1764, R12
B callbackasm1(SB)
MOVW $1765, R12
B callbackasm1(SB)
MOVW $1766, R12
B callbackasm1(SB)
MOVW $1767, R12
B callbackasm1(SB)
MOVW $1768, R12
B callbackasm1(SB)
MOVW $1769, R12
B callbackasm1(SB)
MOVW $1770, R12
B callbackasm1(SB)
MOVW $1771, R12
B callbackasm1(SB)
MOVW $1772, R12
B callbackasm1(SB)
MOVW $1773, R12
B callbackasm1(SB)
MOVW $1774, R12
B callbackasm1(SB)
MOVW $1775, R12
B callbackasm1(SB)
MOVW $1776, R12
B callbackasm1(SB)
MOVW $1777, R12
B callbackasm1(SB)
MOVW $1778, R12
B callbackasm1(SB)
MOVW $1779, R12
B callbackasm1(SB)
MOVW $1780, R12
B callbackasm1(SB)
MOVW $1781, R12
B callbackasm1(SB)
MOVW $1782, R12
B callbackasm1(SB)
MOVW $1783, R12
B callbackasm1(SB)
MOVW $1784, R12
B callbackasm1(SB)
MOVW $1785, R12
B callbackasm1(SB)
MOVW $1786, R12
B callbackasm1(SB)
MOVW $1787, R12
B callbackasm1(SB)
MOVW $1788, R12
B callbackasm1(SB)
MOVW $1789, R12
B callbackasm1(SB)
MOVW $1790, R12
B callbackasm1(SB)
MOVW $1791, R12
B callbackasm1(SB)
MOVW $1792, R12
B callbackasm1(SB)
MOVW $1793, R12
B callbackasm1(SB)
MOVW $1794, R12
B callbackasm1(SB)
MOVW $1795, R12
B callbackasm1(SB)
MOVW $1796, R12
B callbackasm1(SB)
MOVW $1797, R12
B callbackasm1(SB)
MOVW $1798, R12
B callbackasm1(SB)
MOVW $1799, R12
B callbackasm1(SB)
MOVW $1800, R12
B callbackasm1(SB)
MOVW $1801, R12
B callbackasm1(SB)
MOVW $1802, R12
B callbackasm1(SB)
MOVW $1803, R12
B callbackasm1(SB)
MOVW $1804, R12
B callbackasm1(SB)
MOVW $1805, R12
B callbackasm1(SB)
MOVW $1806, R12
B callbackasm1(SB)
MOVW $1807, R12
B callbackasm1(SB)
MOVW $1808, R12
B callbackasm1(SB)
MOVW $1809, R12
B callbackasm1(SB)
MOVW $1810, R12
B callbackasm1(SB)
MOVW $1811, R12
B callbackasm1(SB)
MOVW $1812, R12
B callbackasm1(SB)
MOVW $1813, R12
B callbackasm1(SB)
MOVW $1814, R12
B callbackasm1(SB)
MOVW $1815, R12
B callbackasm1(SB)
MOVW $1816, R12
B callbackasm1(SB)
MOVW $1817, R12
B callbackasm1(SB)
MOVW $1818, R12
B callbackasm1(SB)
MOVW $1819, R12
B callbackasm1(SB)
MOVW $1820, R12
B callbackasm1(SB)
MOVW $1821, R12
B callbackasm1(SB)
MOVW $1822, R12
B callbackasm1(SB)
MOVW $1823, R12
B callbackasm1(SB)
MOVW $1824, R12
B callbackasm1(SB)
MOVW $1825, R12
B callbackasm1(SB)
MOVW $1826, R12
B callbackasm1(SB)
MOVW $1827, R12
B callbackasm1(SB)
MOVW $1828, R12
B callbackasm1(SB)
MOVW $1829, R12
B callbackasm1(SB)
MOVW $1830, R12
B callbackasm1(SB)
MOVW $1831, R12
B callbackasm1(SB)
MOVW $1832, R12
B callbackasm1(SB)
MOVW $1833, R12
B callbackasm1(SB)
MOVW $1834, R12
B callbackasm1(SB)
MOVW $1835, R12
B callbackasm1(SB)
MOVW $1836, R12
B callbackasm1(SB)
MOVW $1837, R12
B callbackasm1(SB)
MOVW $1838, R12
B callbackasm1(SB)
MOVW $1839, R12
B callbackasm1(SB)
MOVW $1840, R12
B callbackasm1(SB)
MOVW $1841, R12
B callbackasm1(SB)
MOVW $1842, R12
B callbackasm1(SB)
MOVW $1843, R12
B callbackasm1(SB)
MOVW $1844, R12
B callbackasm1(SB)
MOVW $1845, R12
B callbackasm1(SB)
MOVW $1846, R12
B callbackasm1(SB)
MOVW $1847, R12
B callbackasm1(SB)
MOVW $1848, R12
B callbackasm1(SB)
MOVW $1849, R12
B callbackasm1(SB)
MOVW $1850, R12
B callbackasm1(SB)
MOVW $1851, R12
B callbackasm1(SB)
MOVW $1852, R12
B callbackasm1(SB)
MOVW $1853, R12
B callbackasm1(SB)
MOVW $1854, R12
B callbackasm1(SB)
MOVW $1855, R12
B callbackasm1(SB)
MOVW $1856, R12
B callbackasm1(SB)
MOVW $1857, R12
B callbackasm1(SB)
MOVW $1858, R12
B callbackasm1(SB)
MOVW $1859, R12
B callbackasm1(SB)
MOVW $1860, R12
B callbackasm1(SB)
MOVW $1861, R12
B callbackasm1(SB)
MOVW $1862, R12
B callbackasm1(SB)
MOVW $1863, R12
B callbackasm1(SB)
MOVW $1864, R12
B callbackasm1(SB)
MOVW $1865, R12
B callbackasm1(SB)
MOVW $1866, R12
B callbackasm1(SB)
MOVW $1867, R12
B callbackasm1(SB)
MOVW $1868, R12
B callbackasm1(SB)
MOVW $1869, R12
B callbackasm1(SB)
MOVW $1870, R12
B callbackasm1(SB)
MOVW $1871, R12
B callbackasm1(SB)
MOVW $1872, R12
B callbackasm1(SB)
MOVW $1873, R12
B callbackasm1(SB)
MOVW $1874, R12
B callbackasm1(SB)
MOVW $1875, R12
B callbackasm1(SB)
MOVW $1876, R12
B callbackasm1(SB)
MOVW $1877, R12
B callbackasm1(SB)
MOVW $1878, R12
B callbackasm1(SB)
MOVW $1879, R12
B callbackasm1(SB)
MOVW $1880, R12
B callbackasm1(SB)
MOVW $1881, R12
B callbackasm1(SB)
MOVW $1882, R12
B callbackasm1(SB)
MOVW $1883, R12
B callbackasm1(SB)
MOVW $1884, R12
B callbackasm1(SB)
MOVW $1885, R12
B callbackasm1(SB)
MOVW $1886, R12
B callbackasm1(SB)
MOVW $1887, R12
B callbackasm1(SB)
MOVW $1888, R12
B callbackasm1(SB)
MOVW $1889, R12
B callbackasm1(SB)
MOVW $1890, R12
B callbackasm1(SB)
MOVW $1891, R12
B callbackasm1(SB)
MOVW $1892, R12
B callbackasm1(SB)
MOVW $1893, R12
B callbackasm1(SB)
MOVW $1894, R12
B callbackasm1(SB)
MOVW $1895, R12
B callbackasm1(SB)
MOVW $1896, R12
B callbackasm1(SB)
MOVW $1897, R12
B callbackasm1(SB)
MOVW $1898, R12
B callbackasm1(SB)
MOVW $1899, R12
B callbackasm1(SB)
MOVW $1900, R12
B callbackasm1(SB)
MOVW $1901, R12
B callbackasm1(SB)
MOVW $1902, R12
B callbackasm1(SB)
MOVW $1903, R12
B callbackasm1(SB)
MOVW $1904, R12
B callbackasm1(SB)
MOVW $1905, R12
B callbackasm1(SB)
MOVW $1906, R12
B callbackasm1(SB)
MOVW $1907, R12
B callbackasm1(SB)
MOVW $1908, R12
B callbackasm1(SB)
MOVW $1909, R12
B callbackasm1(SB)
MOVW $1910, R12
B callbackasm1(SB)
MOVW $1911, R12
B callbackasm1(SB)
MOVW $1912, R12
B callbackasm1(SB)
MOVW $1913, R12
B callbackasm1(SB)
MOVW $1914, R12
B callbackasm1(SB)
MOVW $1915, R12
B callbackasm1(SB)
MOVW $1916, R12
B callbackasm1(SB)
MOVW $1917, R12
B callbackasm1(SB)
MOVW $1918, R12
B callbackasm1(SB)
MOVW $1919, R12
B callbackasm1(SB)
MOVW $1920, R12
B callbackasm1(SB)
MOVW $1921, R12
B callbackasm1(SB)
MOVW $1922, R12
B callbackasm1(SB)
MOVW $1923, R12
B callbackasm1(SB)
MOVW $1924, R12
B callbackasm1(SB)
MOVW $1925, R12
B callbackasm1(SB)
MOVW $1926, R12
B callbackasm1(SB)
MOVW $1927, R12
B callbackasm1(SB)
MOVW $1928, R12
B callbackasm1(SB)
MOVW $1929, R12
B callbackasm1(SB)
MOVW $1930, R12
B callbackasm1(SB)
MOVW $1931, R12
B callbackasm1(SB)
MOVW $1932, R12
B callbackasm1(SB)
MOVW $1933, R12
B callbackasm1(SB)
MOVW $1934, R12
B callbackasm1(SB)
MOVW $1935, R12
B callbackasm1(SB)
MOVW $1936, R12
B callbackasm1(SB)
MOVW $1937, R12
B callbackasm1(SB)
MOVW $1938, R12
B callbackasm1(SB)
MOVW $1939, R12
B callbackasm1(SB)
MOVW $1940, R12
B callbackasm1(SB)
MOVW $1941, R12
B callbackasm1(SB)
MOVW $1942, R12
B callbackasm1(SB)
MOVW $1943, R12
B callbackasm1(SB)
MOVW $1944, R12
B callbackasm1(SB)
MOVW $1945, R12
B callbackasm1(SB)
MOVW $1946, R12
B callbackasm1(SB)
MOVW $1947, R12
B callbackasm1(SB)
MOVW $1948, R12
B callbackasm1(SB)
MOVW $1949, R12
B callbackasm1(SB)
MOVW $1950, R12
B callbackasm1(SB)
MOVW $1951, R12
B callbackasm1(SB)
MOVW $1952, R12
B callbackasm1(SB)
MOVW $1953, R12
B callbackasm1(SB)
MOVW $1954, R12
B callbackasm1(SB)
MOVW $1955, R12
B callbackasm1(SB)
MOVW $1956, R12
B callbackasm1(SB)
MOVW $1957, R12
B callbackasm1(SB)
MOVW $1958, R12
B callbackasm1(SB)
MOVW $1959, R12
B callbackasm1(SB)
MOVW $1960, R12
B callbackasm1(SB)
MOVW $1961, R12
B callbackasm1(SB)
MOVW $1962, R12
B callbackasm1(SB)
MOVW $1963, R12
B callbackasm1(SB)
MOVW $1964, R12
B callbackasm1(SB)
MOVW $1965, R12
B callbackasm1(SB)
MOVW $1966, R12
B callbackasm1(SB)
MOVW $1967, R12
B callbackasm1(SB)
MOVW $1968, R12
B callbackasm1(SB)
MOVW $1969, R12
B callbackasm1(SB)
MOVW $1970, R12
B callbackasm1(SB)
MOVW $1971, R12
B callbackasm1(SB)
MOVW $1972, R12
B callbackasm1(SB)
MOVW $1973, R12
B callbackasm1(SB)
MOVW $1974, R12
B callbackasm1(SB)
MOVW $1975, R12
B callbackasm1(SB)
MOVW $1976, R12
B callbackasm1(SB)
MOVW $1977, R12
B callbackasm1(SB)
MOVW $1978, R12
B callbackasm1(SB)
MOVW $1979, R12
B callbackasm1(SB)
MOVW $1980, R12
B callbackasm1(SB)
MOVW $1981, R12
B callbackasm1(SB)
MOVW $1982, R12
B callbackasm1(SB)
MOVW $1983, R12
B callbackasm1(SB)
MOVW $1984, R12
B callbackasm1(SB)
MOVW $1985, R12
B callbackasm1(SB)
MOVW $1986, R12
B callbackasm1(SB)
MOVW $1987, R12
B callbackasm1(SB)
MOVW $1988, R12
B callbackasm1(SB)
MOVW $1989, R12
B callbackasm1(SB)
MOVW $1990, R12
B callbackasm1(SB)
MOVW $1991, R12
B callbackasm1(SB)
MOVW $1992, R12
B callbackasm1(SB)
MOVW $1993, R12
B callbackasm1(SB)
MOVW $1994, R12
B callbackasm1(SB)
MOVW $1995, R12
B callbackasm1(SB)
MOVW $1996, R12
B callbackasm1(SB)
MOVW $1997, R12
B callbackasm1(SB)
MOVW $1998, R12
B callbackasm1(SB)
MOVW $1999, R12
B callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_arm64.s 0000664 0000000 0000000 00000233225 15207302613 0023057 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOV and B instructions.
// The MOV instruction loads R12 with the callback index, and the
// B instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVD $0, R12
B callbackasm1(SB)
MOVD $1, R12
B callbackasm1(SB)
MOVD $2, R12
B callbackasm1(SB)
MOVD $3, R12
B callbackasm1(SB)
MOVD $4, R12
B callbackasm1(SB)
MOVD $5, R12
B callbackasm1(SB)
MOVD $6, R12
B callbackasm1(SB)
MOVD $7, R12
B callbackasm1(SB)
MOVD $8, R12
B callbackasm1(SB)
MOVD $9, R12
B callbackasm1(SB)
MOVD $10, R12
B callbackasm1(SB)
MOVD $11, R12
B callbackasm1(SB)
MOVD $12, R12
B callbackasm1(SB)
MOVD $13, R12
B callbackasm1(SB)
MOVD $14, R12
B callbackasm1(SB)
MOVD $15, R12
B callbackasm1(SB)
MOVD $16, R12
B callbackasm1(SB)
MOVD $17, R12
B callbackasm1(SB)
MOVD $18, R12
B callbackasm1(SB)
MOVD $19, R12
B callbackasm1(SB)
MOVD $20, R12
B callbackasm1(SB)
MOVD $21, R12
B callbackasm1(SB)
MOVD $22, R12
B callbackasm1(SB)
MOVD $23, R12
B callbackasm1(SB)
MOVD $24, R12
B callbackasm1(SB)
MOVD $25, R12
B callbackasm1(SB)
MOVD $26, R12
B callbackasm1(SB)
MOVD $27, R12
B callbackasm1(SB)
MOVD $28, R12
B callbackasm1(SB)
MOVD $29, R12
B callbackasm1(SB)
MOVD $30, R12
B callbackasm1(SB)
MOVD $31, R12
B callbackasm1(SB)
MOVD $32, R12
B callbackasm1(SB)
MOVD $33, R12
B callbackasm1(SB)
MOVD $34, R12
B callbackasm1(SB)
MOVD $35, R12
B callbackasm1(SB)
MOVD $36, R12
B callbackasm1(SB)
MOVD $37, R12
B callbackasm1(SB)
MOVD $38, R12
B callbackasm1(SB)
MOVD $39, R12
B callbackasm1(SB)
MOVD $40, R12
B callbackasm1(SB)
MOVD $41, R12
B callbackasm1(SB)
MOVD $42, R12
B callbackasm1(SB)
MOVD $43, R12
B callbackasm1(SB)
MOVD $44, R12
B callbackasm1(SB)
MOVD $45, R12
B callbackasm1(SB)
MOVD $46, R12
B callbackasm1(SB)
MOVD $47, R12
B callbackasm1(SB)
MOVD $48, R12
B callbackasm1(SB)
MOVD $49, R12
B callbackasm1(SB)
MOVD $50, R12
B callbackasm1(SB)
MOVD $51, R12
B callbackasm1(SB)
MOVD $52, R12
B callbackasm1(SB)
MOVD $53, R12
B callbackasm1(SB)
MOVD $54, R12
B callbackasm1(SB)
MOVD $55, R12
B callbackasm1(SB)
MOVD $56, R12
B callbackasm1(SB)
MOVD $57, R12
B callbackasm1(SB)
MOVD $58, R12
B callbackasm1(SB)
MOVD $59, R12
B callbackasm1(SB)
MOVD $60, R12
B callbackasm1(SB)
MOVD $61, R12
B callbackasm1(SB)
MOVD $62, R12
B callbackasm1(SB)
MOVD $63, R12
B callbackasm1(SB)
MOVD $64, R12
B callbackasm1(SB)
MOVD $65, R12
B callbackasm1(SB)
MOVD $66, R12
B callbackasm1(SB)
MOVD $67, R12
B callbackasm1(SB)
MOVD $68, R12
B callbackasm1(SB)
MOVD $69, R12
B callbackasm1(SB)
MOVD $70, R12
B callbackasm1(SB)
MOVD $71, R12
B callbackasm1(SB)
MOVD $72, R12
B callbackasm1(SB)
MOVD $73, R12
B callbackasm1(SB)
MOVD $74, R12
B callbackasm1(SB)
MOVD $75, R12
B callbackasm1(SB)
MOVD $76, R12
B callbackasm1(SB)
MOVD $77, R12
B callbackasm1(SB)
MOVD $78, R12
B callbackasm1(SB)
MOVD $79, R12
B callbackasm1(SB)
MOVD $80, R12
B callbackasm1(SB)
MOVD $81, R12
B callbackasm1(SB)
MOVD $82, R12
B callbackasm1(SB)
MOVD $83, R12
B callbackasm1(SB)
MOVD $84, R12
B callbackasm1(SB)
MOVD $85, R12
B callbackasm1(SB)
MOVD $86, R12
B callbackasm1(SB)
MOVD $87, R12
B callbackasm1(SB)
MOVD $88, R12
B callbackasm1(SB)
MOVD $89, R12
B callbackasm1(SB)
MOVD $90, R12
B callbackasm1(SB)
MOVD $91, R12
B callbackasm1(SB)
MOVD $92, R12
B callbackasm1(SB)
MOVD $93, R12
B callbackasm1(SB)
MOVD $94, R12
B callbackasm1(SB)
MOVD $95, R12
B callbackasm1(SB)
MOVD $96, R12
B callbackasm1(SB)
MOVD $97, R12
B callbackasm1(SB)
MOVD $98, R12
B callbackasm1(SB)
MOVD $99, R12
B callbackasm1(SB)
MOVD $100, R12
B callbackasm1(SB)
MOVD $101, R12
B callbackasm1(SB)
MOVD $102, R12
B callbackasm1(SB)
MOVD $103, R12
B callbackasm1(SB)
MOVD $104, R12
B callbackasm1(SB)
MOVD $105, R12
B callbackasm1(SB)
MOVD $106, R12
B callbackasm1(SB)
MOVD $107, R12
B callbackasm1(SB)
MOVD $108, R12
B callbackasm1(SB)
MOVD $109, R12
B callbackasm1(SB)
MOVD $110, R12
B callbackasm1(SB)
MOVD $111, R12
B callbackasm1(SB)
MOVD $112, R12
B callbackasm1(SB)
MOVD $113, R12
B callbackasm1(SB)
MOVD $114, R12
B callbackasm1(SB)
MOVD $115, R12
B callbackasm1(SB)
MOVD $116, R12
B callbackasm1(SB)
MOVD $117, R12
B callbackasm1(SB)
MOVD $118, R12
B callbackasm1(SB)
MOVD $119, R12
B callbackasm1(SB)
MOVD $120, R12
B callbackasm1(SB)
MOVD $121, R12
B callbackasm1(SB)
MOVD $122, R12
B callbackasm1(SB)
MOVD $123, R12
B callbackasm1(SB)
MOVD $124, R12
B callbackasm1(SB)
MOVD $125, R12
B callbackasm1(SB)
MOVD $126, R12
B callbackasm1(SB)
MOVD $127, R12
B callbackasm1(SB)
MOVD $128, R12
B callbackasm1(SB)
MOVD $129, R12
B callbackasm1(SB)
MOVD $130, R12
B callbackasm1(SB)
MOVD $131, R12
B callbackasm1(SB)
MOVD $132, R12
B callbackasm1(SB)
MOVD $133, R12
B callbackasm1(SB)
MOVD $134, R12
B callbackasm1(SB)
MOVD $135, R12
B callbackasm1(SB)
MOVD $136, R12
B callbackasm1(SB)
MOVD $137, R12
B callbackasm1(SB)
MOVD $138, R12
B callbackasm1(SB)
MOVD $139, R12
B callbackasm1(SB)
MOVD $140, R12
B callbackasm1(SB)
MOVD $141, R12
B callbackasm1(SB)
MOVD $142, R12
B callbackasm1(SB)
MOVD $143, R12
B callbackasm1(SB)
MOVD $144, R12
B callbackasm1(SB)
MOVD $145, R12
B callbackasm1(SB)
MOVD $146, R12
B callbackasm1(SB)
MOVD $147, R12
B callbackasm1(SB)
MOVD $148, R12
B callbackasm1(SB)
MOVD $149, R12
B callbackasm1(SB)
MOVD $150, R12
B callbackasm1(SB)
MOVD $151, R12
B callbackasm1(SB)
MOVD $152, R12
B callbackasm1(SB)
MOVD $153, R12
B callbackasm1(SB)
MOVD $154, R12
B callbackasm1(SB)
MOVD $155, R12
B callbackasm1(SB)
MOVD $156, R12
B callbackasm1(SB)
MOVD $157, R12
B callbackasm1(SB)
MOVD $158, R12
B callbackasm1(SB)
MOVD $159, R12
B callbackasm1(SB)
MOVD $160, R12
B callbackasm1(SB)
MOVD $161, R12
B callbackasm1(SB)
MOVD $162, R12
B callbackasm1(SB)
MOVD $163, R12
B callbackasm1(SB)
MOVD $164, R12
B callbackasm1(SB)
MOVD $165, R12
B callbackasm1(SB)
MOVD $166, R12
B callbackasm1(SB)
MOVD $167, R12
B callbackasm1(SB)
MOVD $168, R12
B callbackasm1(SB)
MOVD $169, R12
B callbackasm1(SB)
MOVD $170, R12
B callbackasm1(SB)
MOVD $171, R12
B callbackasm1(SB)
MOVD $172, R12
B callbackasm1(SB)
MOVD $173, R12
B callbackasm1(SB)
MOVD $174, R12
B callbackasm1(SB)
MOVD $175, R12
B callbackasm1(SB)
MOVD $176, R12
B callbackasm1(SB)
MOVD $177, R12
B callbackasm1(SB)
MOVD $178, R12
B callbackasm1(SB)
MOVD $179, R12
B callbackasm1(SB)
MOVD $180, R12
B callbackasm1(SB)
MOVD $181, R12
B callbackasm1(SB)
MOVD $182, R12
B callbackasm1(SB)
MOVD $183, R12
B callbackasm1(SB)
MOVD $184, R12
B callbackasm1(SB)
MOVD $185, R12
B callbackasm1(SB)
MOVD $186, R12
B callbackasm1(SB)
MOVD $187, R12
B callbackasm1(SB)
MOVD $188, R12
B callbackasm1(SB)
MOVD $189, R12
B callbackasm1(SB)
MOVD $190, R12
B callbackasm1(SB)
MOVD $191, R12
B callbackasm1(SB)
MOVD $192, R12
B callbackasm1(SB)
MOVD $193, R12
B callbackasm1(SB)
MOVD $194, R12
B callbackasm1(SB)
MOVD $195, R12
B callbackasm1(SB)
MOVD $196, R12
B callbackasm1(SB)
MOVD $197, R12
B callbackasm1(SB)
MOVD $198, R12
B callbackasm1(SB)
MOVD $199, R12
B callbackasm1(SB)
MOVD $200, R12
B callbackasm1(SB)
MOVD $201, R12
B callbackasm1(SB)
MOVD $202, R12
B callbackasm1(SB)
MOVD $203, R12
B callbackasm1(SB)
MOVD $204, R12
B callbackasm1(SB)
MOVD $205, R12
B callbackasm1(SB)
MOVD $206, R12
B callbackasm1(SB)
MOVD $207, R12
B callbackasm1(SB)
MOVD $208, R12
B callbackasm1(SB)
MOVD $209, R12
B callbackasm1(SB)
MOVD $210, R12
B callbackasm1(SB)
MOVD $211, R12
B callbackasm1(SB)
MOVD $212, R12
B callbackasm1(SB)
MOVD $213, R12
B callbackasm1(SB)
MOVD $214, R12
B callbackasm1(SB)
MOVD $215, R12
B callbackasm1(SB)
MOVD $216, R12
B callbackasm1(SB)
MOVD $217, R12
B callbackasm1(SB)
MOVD $218, R12
B callbackasm1(SB)
MOVD $219, R12
B callbackasm1(SB)
MOVD $220, R12
B callbackasm1(SB)
MOVD $221, R12
B callbackasm1(SB)
MOVD $222, R12
B callbackasm1(SB)
MOVD $223, R12
B callbackasm1(SB)
MOVD $224, R12
B callbackasm1(SB)
MOVD $225, R12
B callbackasm1(SB)
MOVD $226, R12
B callbackasm1(SB)
MOVD $227, R12
B callbackasm1(SB)
MOVD $228, R12
B callbackasm1(SB)
MOVD $229, R12
B callbackasm1(SB)
MOVD $230, R12
B callbackasm1(SB)
MOVD $231, R12
B callbackasm1(SB)
MOVD $232, R12
B callbackasm1(SB)
MOVD $233, R12
B callbackasm1(SB)
MOVD $234, R12
B callbackasm1(SB)
MOVD $235, R12
B callbackasm1(SB)
MOVD $236, R12
B callbackasm1(SB)
MOVD $237, R12
B callbackasm1(SB)
MOVD $238, R12
B callbackasm1(SB)
MOVD $239, R12
B callbackasm1(SB)
MOVD $240, R12
B callbackasm1(SB)
MOVD $241, R12
B callbackasm1(SB)
MOVD $242, R12
B callbackasm1(SB)
MOVD $243, R12
B callbackasm1(SB)
MOVD $244, R12
B callbackasm1(SB)
MOVD $245, R12
B callbackasm1(SB)
MOVD $246, R12
B callbackasm1(SB)
MOVD $247, R12
B callbackasm1(SB)
MOVD $248, R12
B callbackasm1(SB)
MOVD $249, R12
B callbackasm1(SB)
MOVD $250, R12
B callbackasm1(SB)
MOVD $251, R12
B callbackasm1(SB)
MOVD $252, R12
B callbackasm1(SB)
MOVD $253, R12
B callbackasm1(SB)
MOVD $254, R12
B callbackasm1(SB)
MOVD $255, R12
B callbackasm1(SB)
MOVD $256, R12
B callbackasm1(SB)
MOVD $257, R12
B callbackasm1(SB)
MOVD $258, R12
B callbackasm1(SB)
MOVD $259, R12
B callbackasm1(SB)
MOVD $260, R12
B callbackasm1(SB)
MOVD $261, R12
B callbackasm1(SB)
MOVD $262, R12
B callbackasm1(SB)
MOVD $263, R12
B callbackasm1(SB)
MOVD $264, R12
B callbackasm1(SB)
MOVD $265, R12
B callbackasm1(SB)
MOVD $266, R12
B callbackasm1(SB)
MOVD $267, R12
B callbackasm1(SB)
MOVD $268, R12
B callbackasm1(SB)
MOVD $269, R12
B callbackasm1(SB)
MOVD $270, R12
B callbackasm1(SB)
MOVD $271, R12
B callbackasm1(SB)
MOVD $272, R12
B callbackasm1(SB)
MOVD $273, R12
B callbackasm1(SB)
MOVD $274, R12
B callbackasm1(SB)
MOVD $275, R12
B callbackasm1(SB)
MOVD $276, R12
B callbackasm1(SB)
MOVD $277, R12
B callbackasm1(SB)
MOVD $278, R12
B callbackasm1(SB)
MOVD $279, R12
B callbackasm1(SB)
MOVD $280, R12
B callbackasm1(SB)
MOVD $281, R12
B callbackasm1(SB)
MOVD $282, R12
B callbackasm1(SB)
MOVD $283, R12
B callbackasm1(SB)
MOVD $284, R12
B callbackasm1(SB)
MOVD $285, R12
B callbackasm1(SB)
MOVD $286, R12
B callbackasm1(SB)
MOVD $287, R12
B callbackasm1(SB)
MOVD $288, R12
B callbackasm1(SB)
MOVD $289, R12
B callbackasm1(SB)
MOVD $290, R12
B callbackasm1(SB)
MOVD $291, R12
B callbackasm1(SB)
MOVD $292, R12
B callbackasm1(SB)
MOVD $293, R12
B callbackasm1(SB)
MOVD $294, R12
B callbackasm1(SB)
MOVD $295, R12
B callbackasm1(SB)
MOVD $296, R12
B callbackasm1(SB)
MOVD $297, R12
B callbackasm1(SB)
MOVD $298, R12
B callbackasm1(SB)
MOVD $299, R12
B callbackasm1(SB)
MOVD $300, R12
B callbackasm1(SB)
MOVD $301, R12
B callbackasm1(SB)
MOVD $302, R12
B callbackasm1(SB)
MOVD $303, R12
B callbackasm1(SB)
MOVD $304, R12
B callbackasm1(SB)
MOVD $305, R12
B callbackasm1(SB)
MOVD $306, R12
B callbackasm1(SB)
MOVD $307, R12
B callbackasm1(SB)
MOVD $308, R12
B callbackasm1(SB)
MOVD $309, R12
B callbackasm1(SB)
MOVD $310, R12
B callbackasm1(SB)
MOVD $311, R12
B callbackasm1(SB)
MOVD $312, R12
B callbackasm1(SB)
MOVD $313, R12
B callbackasm1(SB)
MOVD $314, R12
B callbackasm1(SB)
MOVD $315, R12
B callbackasm1(SB)
MOVD $316, R12
B callbackasm1(SB)
MOVD $317, R12
B callbackasm1(SB)
MOVD $318, R12
B callbackasm1(SB)
MOVD $319, R12
B callbackasm1(SB)
MOVD $320, R12
B callbackasm1(SB)
MOVD $321, R12
B callbackasm1(SB)
MOVD $322, R12
B callbackasm1(SB)
MOVD $323, R12
B callbackasm1(SB)
MOVD $324, R12
B callbackasm1(SB)
MOVD $325, R12
B callbackasm1(SB)
MOVD $326, R12
B callbackasm1(SB)
MOVD $327, R12
B callbackasm1(SB)
MOVD $328, R12
B callbackasm1(SB)
MOVD $329, R12
B callbackasm1(SB)
MOVD $330, R12
B callbackasm1(SB)
MOVD $331, R12
B callbackasm1(SB)
MOVD $332, R12
B callbackasm1(SB)
MOVD $333, R12
B callbackasm1(SB)
MOVD $334, R12
B callbackasm1(SB)
MOVD $335, R12
B callbackasm1(SB)
MOVD $336, R12
B callbackasm1(SB)
MOVD $337, R12
B callbackasm1(SB)
MOVD $338, R12
B callbackasm1(SB)
MOVD $339, R12
B callbackasm1(SB)
MOVD $340, R12
B callbackasm1(SB)
MOVD $341, R12
B callbackasm1(SB)
MOVD $342, R12
B callbackasm1(SB)
MOVD $343, R12
B callbackasm1(SB)
MOVD $344, R12
B callbackasm1(SB)
MOVD $345, R12
B callbackasm1(SB)
MOVD $346, R12
B callbackasm1(SB)
MOVD $347, R12
B callbackasm1(SB)
MOVD $348, R12
B callbackasm1(SB)
MOVD $349, R12
B callbackasm1(SB)
MOVD $350, R12
B callbackasm1(SB)
MOVD $351, R12
B callbackasm1(SB)
MOVD $352, R12
B callbackasm1(SB)
MOVD $353, R12
B callbackasm1(SB)
MOVD $354, R12
B callbackasm1(SB)
MOVD $355, R12
B callbackasm1(SB)
MOVD $356, R12
B callbackasm1(SB)
MOVD $357, R12
B callbackasm1(SB)
MOVD $358, R12
B callbackasm1(SB)
MOVD $359, R12
B callbackasm1(SB)
MOVD $360, R12
B callbackasm1(SB)
MOVD $361, R12
B callbackasm1(SB)
MOVD $362, R12
B callbackasm1(SB)
MOVD $363, R12
B callbackasm1(SB)
MOVD $364, R12
B callbackasm1(SB)
MOVD $365, R12
B callbackasm1(SB)
MOVD $366, R12
B callbackasm1(SB)
MOVD $367, R12
B callbackasm1(SB)
MOVD $368, R12
B callbackasm1(SB)
MOVD $369, R12
B callbackasm1(SB)
MOVD $370, R12
B callbackasm1(SB)
MOVD $371, R12
B callbackasm1(SB)
MOVD $372, R12
B callbackasm1(SB)
MOVD $373, R12
B callbackasm1(SB)
MOVD $374, R12
B callbackasm1(SB)
MOVD $375, R12
B callbackasm1(SB)
MOVD $376, R12
B callbackasm1(SB)
MOVD $377, R12
B callbackasm1(SB)
MOVD $378, R12
B callbackasm1(SB)
MOVD $379, R12
B callbackasm1(SB)
MOVD $380, R12
B callbackasm1(SB)
MOVD $381, R12
B callbackasm1(SB)
MOVD $382, R12
B callbackasm1(SB)
MOVD $383, R12
B callbackasm1(SB)
MOVD $384, R12
B callbackasm1(SB)
MOVD $385, R12
B callbackasm1(SB)
MOVD $386, R12
B callbackasm1(SB)
MOVD $387, R12
B callbackasm1(SB)
MOVD $388, R12
B callbackasm1(SB)
MOVD $389, R12
B callbackasm1(SB)
MOVD $390, R12
B callbackasm1(SB)
MOVD $391, R12
B callbackasm1(SB)
MOVD $392, R12
B callbackasm1(SB)
MOVD $393, R12
B callbackasm1(SB)
MOVD $394, R12
B callbackasm1(SB)
MOVD $395, R12
B callbackasm1(SB)
MOVD $396, R12
B callbackasm1(SB)
MOVD $397, R12
B callbackasm1(SB)
MOVD $398, R12
B callbackasm1(SB)
MOVD $399, R12
B callbackasm1(SB)
MOVD $400, R12
B callbackasm1(SB)
MOVD $401, R12
B callbackasm1(SB)
MOVD $402, R12
B callbackasm1(SB)
MOVD $403, R12
B callbackasm1(SB)
MOVD $404, R12
B callbackasm1(SB)
MOVD $405, R12
B callbackasm1(SB)
MOVD $406, R12
B callbackasm1(SB)
MOVD $407, R12
B callbackasm1(SB)
MOVD $408, R12
B callbackasm1(SB)
MOVD $409, R12
B callbackasm1(SB)
MOVD $410, R12
B callbackasm1(SB)
MOVD $411, R12
B callbackasm1(SB)
MOVD $412, R12
B callbackasm1(SB)
MOVD $413, R12
B callbackasm1(SB)
MOVD $414, R12
B callbackasm1(SB)
MOVD $415, R12
B callbackasm1(SB)
MOVD $416, R12
B callbackasm1(SB)
MOVD $417, R12
B callbackasm1(SB)
MOVD $418, R12
B callbackasm1(SB)
MOVD $419, R12
B callbackasm1(SB)
MOVD $420, R12
B callbackasm1(SB)
MOVD $421, R12
B callbackasm1(SB)
MOVD $422, R12
B callbackasm1(SB)
MOVD $423, R12
B callbackasm1(SB)
MOVD $424, R12
B callbackasm1(SB)
MOVD $425, R12
B callbackasm1(SB)
MOVD $426, R12
B callbackasm1(SB)
MOVD $427, R12
B callbackasm1(SB)
MOVD $428, R12
B callbackasm1(SB)
MOVD $429, R12
B callbackasm1(SB)
MOVD $430, R12
B callbackasm1(SB)
MOVD $431, R12
B callbackasm1(SB)
MOVD $432, R12
B callbackasm1(SB)
MOVD $433, R12
B callbackasm1(SB)
MOVD $434, R12
B callbackasm1(SB)
MOVD $435, R12
B callbackasm1(SB)
MOVD $436, R12
B callbackasm1(SB)
MOVD $437, R12
B callbackasm1(SB)
MOVD $438, R12
B callbackasm1(SB)
MOVD $439, R12
B callbackasm1(SB)
MOVD $440, R12
B callbackasm1(SB)
MOVD $441, R12
B callbackasm1(SB)
MOVD $442, R12
B callbackasm1(SB)
MOVD $443, R12
B callbackasm1(SB)
MOVD $444, R12
B callbackasm1(SB)
MOVD $445, R12
B callbackasm1(SB)
MOVD $446, R12
B callbackasm1(SB)
MOVD $447, R12
B callbackasm1(SB)
MOVD $448, R12
B callbackasm1(SB)
MOVD $449, R12
B callbackasm1(SB)
MOVD $450, R12
B callbackasm1(SB)
MOVD $451, R12
B callbackasm1(SB)
MOVD $452, R12
B callbackasm1(SB)
MOVD $453, R12
B callbackasm1(SB)
MOVD $454, R12
B callbackasm1(SB)
MOVD $455, R12
B callbackasm1(SB)
MOVD $456, R12
B callbackasm1(SB)
MOVD $457, R12
B callbackasm1(SB)
MOVD $458, R12
B callbackasm1(SB)
MOVD $459, R12
B callbackasm1(SB)
MOVD $460, R12
B callbackasm1(SB)
MOVD $461, R12
B callbackasm1(SB)
MOVD $462, R12
B callbackasm1(SB)
MOVD $463, R12
B callbackasm1(SB)
MOVD $464, R12
B callbackasm1(SB)
MOVD $465, R12
B callbackasm1(SB)
MOVD $466, R12
B callbackasm1(SB)
MOVD $467, R12
B callbackasm1(SB)
MOVD $468, R12
B callbackasm1(SB)
MOVD $469, R12
B callbackasm1(SB)
MOVD $470, R12
B callbackasm1(SB)
MOVD $471, R12
B callbackasm1(SB)
MOVD $472, R12
B callbackasm1(SB)
MOVD $473, R12
B callbackasm1(SB)
MOVD $474, R12
B callbackasm1(SB)
MOVD $475, R12
B callbackasm1(SB)
MOVD $476, R12
B callbackasm1(SB)
MOVD $477, R12
B callbackasm1(SB)
MOVD $478, R12
B callbackasm1(SB)
MOVD $479, R12
B callbackasm1(SB)
MOVD $480, R12
B callbackasm1(SB)
MOVD $481, R12
B callbackasm1(SB)
MOVD $482, R12
B callbackasm1(SB)
MOVD $483, R12
B callbackasm1(SB)
MOVD $484, R12
B callbackasm1(SB)
MOVD $485, R12
B callbackasm1(SB)
MOVD $486, R12
B callbackasm1(SB)
MOVD $487, R12
B callbackasm1(SB)
MOVD $488, R12
B callbackasm1(SB)
MOVD $489, R12
B callbackasm1(SB)
MOVD $490, R12
B callbackasm1(SB)
MOVD $491, R12
B callbackasm1(SB)
MOVD $492, R12
B callbackasm1(SB)
MOVD $493, R12
B callbackasm1(SB)
MOVD $494, R12
B callbackasm1(SB)
MOVD $495, R12
B callbackasm1(SB)
MOVD $496, R12
B callbackasm1(SB)
MOVD $497, R12
B callbackasm1(SB)
MOVD $498, R12
B callbackasm1(SB)
MOVD $499, R12
B callbackasm1(SB)
MOVD $500, R12
B callbackasm1(SB)
MOVD $501, R12
B callbackasm1(SB)
MOVD $502, R12
B callbackasm1(SB)
MOVD $503, R12
B callbackasm1(SB)
MOVD $504, R12
B callbackasm1(SB)
MOVD $505, R12
B callbackasm1(SB)
MOVD $506, R12
B callbackasm1(SB)
MOVD $507, R12
B callbackasm1(SB)
MOVD $508, R12
B callbackasm1(SB)
MOVD $509, R12
B callbackasm1(SB)
MOVD $510, R12
B callbackasm1(SB)
MOVD $511, R12
B callbackasm1(SB)
MOVD $512, R12
B callbackasm1(SB)
MOVD $513, R12
B callbackasm1(SB)
MOVD $514, R12
B callbackasm1(SB)
MOVD $515, R12
B callbackasm1(SB)
MOVD $516, R12
B callbackasm1(SB)
MOVD $517, R12
B callbackasm1(SB)
MOVD $518, R12
B callbackasm1(SB)
MOVD $519, R12
B callbackasm1(SB)
MOVD $520, R12
B callbackasm1(SB)
MOVD $521, R12
B callbackasm1(SB)
MOVD $522, R12
B callbackasm1(SB)
MOVD $523, R12
B callbackasm1(SB)
MOVD $524, R12
B callbackasm1(SB)
MOVD $525, R12
B callbackasm1(SB)
MOVD $526, R12
B callbackasm1(SB)
MOVD $527, R12
B callbackasm1(SB)
MOVD $528, R12
B callbackasm1(SB)
MOVD $529, R12
B callbackasm1(SB)
MOVD $530, R12
B callbackasm1(SB)
MOVD $531, R12
B callbackasm1(SB)
MOVD $532, R12
B callbackasm1(SB)
MOVD $533, R12
B callbackasm1(SB)
MOVD $534, R12
B callbackasm1(SB)
MOVD $535, R12
B callbackasm1(SB)
MOVD $536, R12
B callbackasm1(SB)
MOVD $537, R12
B callbackasm1(SB)
MOVD $538, R12
B callbackasm1(SB)
MOVD $539, R12
B callbackasm1(SB)
MOVD $540, R12
B callbackasm1(SB)
MOVD $541, R12
B callbackasm1(SB)
MOVD $542, R12
B callbackasm1(SB)
MOVD $543, R12
B callbackasm1(SB)
MOVD $544, R12
B callbackasm1(SB)
MOVD $545, R12
B callbackasm1(SB)
MOVD $546, R12
B callbackasm1(SB)
MOVD $547, R12
B callbackasm1(SB)
MOVD $548, R12
B callbackasm1(SB)
MOVD $549, R12
B callbackasm1(SB)
MOVD $550, R12
B callbackasm1(SB)
MOVD $551, R12
B callbackasm1(SB)
MOVD $552, R12
B callbackasm1(SB)
MOVD $553, R12
B callbackasm1(SB)
MOVD $554, R12
B callbackasm1(SB)
MOVD $555, R12
B callbackasm1(SB)
MOVD $556, R12
B callbackasm1(SB)
MOVD $557, R12
B callbackasm1(SB)
MOVD $558, R12
B callbackasm1(SB)
MOVD $559, R12
B callbackasm1(SB)
MOVD $560, R12
B callbackasm1(SB)
MOVD $561, R12
B callbackasm1(SB)
MOVD $562, R12
B callbackasm1(SB)
MOVD $563, R12
B callbackasm1(SB)
MOVD $564, R12
B callbackasm1(SB)
MOVD $565, R12
B callbackasm1(SB)
MOVD $566, R12
B callbackasm1(SB)
MOVD $567, R12
B callbackasm1(SB)
MOVD $568, R12
B callbackasm1(SB)
MOVD $569, R12
B callbackasm1(SB)
MOVD $570, R12
B callbackasm1(SB)
MOVD $571, R12
B callbackasm1(SB)
MOVD $572, R12
B callbackasm1(SB)
MOVD $573, R12
B callbackasm1(SB)
MOVD $574, R12
B callbackasm1(SB)
MOVD $575, R12
B callbackasm1(SB)
MOVD $576, R12
B callbackasm1(SB)
MOVD $577, R12
B callbackasm1(SB)
MOVD $578, R12
B callbackasm1(SB)
MOVD $579, R12
B callbackasm1(SB)
MOVD $580, R12
B callbackasm1(SB)
MOVD $581, R12
B callbackasm1(SB)
MOVD $582, R12
B callbackasm1(SB)
MOVD $583, R12
B callbackasm1(SB)
MOVD $584, R12
B callbackasm1(SB)
MOVD $585, R12
B callbackasm1(SB)
MOVD $586, R12
B callbackasm1(SB)
MOVD $587, R12
B callbackasm1(SB)
MOVD $588, R12
B callbackasm1(SB)
MOVD $589, R12
B callbackasm1(SB)
MOVD $590, R12
B callbackasm1(SB)
MOVD $591, R12
B callbackasm1(SB)
MOVD $592, R12
B callbackasm1(SB)
MOVD $593, R12
B callbackasm1(SB)
MOVD $594, R12
B callbackasm1(SB)
MOVD $595, R12
B callbackasm1(SB)
MOVD $596, R12
B callbackasm1(SB)
MOVD $597, R12
B callbackasm1(SB)
MOVD $598, R12
B callbackasm1(SB)
MOVD $599, R12
B callbackasm1(SB)
MOVD $600, R12
B callbackasm1(SB)
MOVD $601, R12
B callbackasm1(SB)
MOVD $602, R12
B callbackasm1(SB)
MOVD $603, R12
B callbackasm1(SB)
MOVD $604, R12
B callbackasm1(SB)
MOVD $605, R12
B callbackasm1(SB)
MOVD $606, R12
B callbackasm1(SB)
MOVD $607, R12
B callbackasm1(SB)
MOVD $608, R12
B callbackasm1(SB)
MOVD $609, R12
B callbackasm1(SB)
MOVD $610, R12
B callbackasm1(SB)
MOVD $611, R12
B callbackasm1(SB)
MOVD $612, R12
B callbackasm1(SB)
MOVD $613, R12
B callbackasm1(SB)
MOVD $614, R12
B callbackasm1(SB)
MOVD $615, R12
B callbackasm1(SB)
MOVD $616, R12
B callbackasm1(SB)
MOVD $617, R12
B callbackasm1(SB)
MOVD $618, R12
B callbackasm1(SB)
MOVD $619, R12
B callbackasm1(SB)
MOVD $620, R12
B callbackasm1(SB)
MOVD $621, R12
B callbackasm1(SB)
MOVD $622, R12
B callbackasm1(SB)
MOVD $623, R12
B callbackasm1(SB)
MOVD $624, R12
B callbackasm1(SB)
MOVD $625, R12
B callbackasm1(SB)
MOVD $626, R12
B callbackasm1(SB)
MOVD $627, R12
B callbackasm1(SB)
MOVD $628, R12
B callbackasm1(SB)
MOVD $629, R12
B callbackasm1(SB)
MOVD $630, R12
B callbackasm1(SB)
MOVD $631, R12
B callbackasm1(SB)
MOVD $632, R12
B callbackasm1(SB)
MOVD $633, R12
B callbackasm1(SB)
MOVD $634, R12
B callbackasm1(SB)
MOVD $635, R12
B callbackasm1(SB)
MOVD $636, R12
B callbackasm1(SB)
MOVD $637, R12
B callbackasm1(SB)
MOVD $638, R12
B callbackasm1(SB)
MOVD $639, R12
B callbackasm1(SB)
MOVD $640, R12
B callbackasm1(SB)
MOVD $641, R12
B callbackasm1(SB)
MOVD $642, R12
B callbackasm1(SB)
MOVD $643, R12
B callbackasm1(SB)
MOVD $644, R12
B callbackasm1(SB)
MOVD $645, R12
B callbackasm1(SB)
MOVD $646, R12
B callbackasm1(SB)
MOVD $647, R12
B callbackasm1(SB)
MOVD $648, R12
B callbackasm1(SB)
MOVD $649, R12
B callbackasm1(SB)
MOVD $650, R12
B callbackasm1(SB)
MOVD $651, R12
B callbackasm1(SB)
MOVD $652, R12
B callbackasm1(SB)
MOVD $653, R12
B callbackasm1(SB)
MOVD $654, R12
B callbackasm1(SB)
MOVD $655, R12
B callbackasm1(SB)
MOVD $656, R12
B callbackasm1(SB)
MOVD $657, R12
B callbackasm1(SB)
MOVD $658, R12
B callbackasm1(SB)
MOVD $659, R12
B callbackasm1(SB)
MOVD $660, R12
B callbackasm1(SB)
MOVD $661, R12
B callbackasm1(SB)
MOVD $662, R12
B callbackasm1(SB)
MOVD $663, R12
B callbackasm1(SB)
MOVD $664, R12
B callbackasm1(SB)
MOVD $665, R12
B callbackasm1(SB)
MOVD $666, R12
B callbackasm1(SB)
MOVD $667, R12
B callbackasm1(SB)
MOVD $668, R12
B callbackasm1(SB)
MOVD $669, R12
B callbackasm1(SB)
MOVD $670, R12
B callbackasm1(SB)
MOVD $671, R12
B callbackasm1(SB)
MOVD $672, R12
B callbackasm1(SB)
MOVD $673, R12
B callbackasm1(SB)
MOVD $674, R12
B callbackasm1(SB)
MOVD $675, R12
B callbackasm1(SB)
MOVD $676, R12
B callbackasm1(SB)
MOVD $677, R12
B callbackasm1(SB)
MOVD $678, R12
B callbackasm1(SB)
MOVD $679, R12
B callbackasm1(SB)
MOVD $680, R12
B callbackasm1(SB)
MOVD $681, R12
B callbackasm1(SB)
MOVD $682, R12
B callbackasm1(SB)
MOVD $683, R12
B callbackasm1(SB)
MOVD $684, R12
B callbackasm1(SB)
MOVD $685, R12
B callbackasm1(SB)
MOVD $686, R12
B callbackasm1(SB)
MOVD $687, R12
B callbackasm1(SB)
MOVD $688, R12
B callbackasm1(SB)
MOVD $689, R12
B callbackasm1(SB)
MOVD $690, R12
B callbackasm1(SB)
MOVD $691, R12
B callbackasm1(SB)
MOVD $692, R12
B callbackasm1(SB)
MOVD $693, R12
B callbackasm1(SB)
MOVD $694, R12
B callbackasm1(SB)
MOVD $695, R12
B callbackasm1(SB)
MOVD $696, R12
B callbackasm1(SB)
MOVD $697, R12
B callbackasm1(SB)
MOVD $698, R12
B callbackasm1(SB)
MOVD $699, R12
B callbackasm1(SB)
MOVD $700, R12
B callbackasm1(SB)
MOVD $701, R12
B callbackasm1(SB)
MOVD $702, R12
B callbackasm1(SB)
MOVD $703, R12
B callbackasm1(SB)
MOVD $704, R12
B callbackasm1(SB)
MOVD $705, R12
B callbackasm1(SB)
MOVD $706, R12
B callbackasm1(SB)
MOVD $707, R12
B callbackasm1(SB)
MOVD $708, R12
B callbackasm1(SB)
MOVD $709, R12
B callbackasm1(SB)
MOVD $710, R12
B callbackasm1(SB)
MOVD $711, R12
B callbackasm1(SB)
MOVD $712, R12
B callbackasm1(SB)
MOVD $713, R12
B callbackasm1(SB)
MOVD $714, R12
B callbackasm1(SB)
MOVD $715, R12
B callbackasm1(SB)
MOVD $716, R12
B callbackasm1(SB)
MOVD $717, R12
B callbackasm1(SB)
MOVD $718, R12
B callbackasm1(SB)
MOVD $719, R12
B callbackasm1(SB)
MOVD $720, R12
B callbackasm1(SB)
MOVD $721, R12
B callbackasm1(SB)
MOVD $722, R12
B callbackasm1(SB)
MOVD $723, R12
B callbackasm1(SB)
MOVD $724, R12
B callbackasm1(SB)
MOVD $725, R12
B callbackasm1(SB)
MOVD $726, R12
B callbackasm1(SB)
MOVD $727, R12
B callbackasm1(SB)
MOVD $728, R12
B callbackasm1(SB)
MOVD $729, R12
B callbackasm1(SB)
MOVD $730, R12
B callbackasm1(SB)
MOVD $731, R12
B callbackasm1(SB)
MOVD $732, R12
B callbackasm1(SB)
MOVD $733, R12
B callbackasm1(SB)
MOVD $734, R12
B callbackasm1(SB)
MOVD $735, R12
B callbackasm1(SB)
MOVD $736, R12
B callbackasm1(SB)
MOVD $737, R12
B callbackasm1(SB)
MOVD $738, R12
B callbackasm1(SB)
MOVD $739, R12
B callbackasm1(SB)
MOVD $740, R12
B callbackasm1(SB)
MOVD $741, R12
B callbackasm1(SB)
MOVD $742, R12
B callbackasm1(SB)
MOVD $743, R12
B callbackasm1(SB)
MOVD $744, R12
B callbackasm1(SB)
MOVD $745, R12
B callbackasm1(SB)
MOVD $746, R12
B callbackasm1(SB)
MOVD $747, R12
B callbackasm1(SB)
MOVD $748, R12
B callbackasm1(SB)
MOVD $749, R12
B callbackasm1(SB)
MOVD $750, R12
B callbackasm1(SB)
MOVD $751, R12
B callbackasm1(SB)
MOVD $752, R12
B callbackasm1(SB)
MOVD $753, R12
B callbackasm1(SB)
MOVD $754, R12
B callbackasm1(SB)
MOVD $755, R12
B callbackasm1(SB)
MOVD $756, R12
B callbackasm1(SB)
MOVD $757, R12
B callbackasm1(SB)
MOVD $758, R12
B callbackasm1(SB)
MOVD $759, R12
B callbackasm1(SB)
MOVD $760, R12
B callbackasm1(SB)
MOVD $761, R12
B callbackasm1(SB)
MOVD $762, R12
B callbackasm1(SB)
MOVD $763, R12
B callbackasm1(SB)
MOVD $764, R12
B callbackasm1(SB)
MOVD $765, R12
B callbackasm1(SB)
MOVD $766, R12
B callbackasm1(SB)
MOVD $767, R12
B callbackasm1(SB)
MOVD $768, R12
B callbackasm1(SB)
MOVD $769, R12
B callbackasm1(SB)
MOVD $770, R12
B callbackasm1(SB)
MOVD $771, R12
B callbackasm1(SB)
MOVD $772, R12
B callbackasm1(SB)
MOVD $773, R12
B callbackasm1(SB)
MOVD $774, R12
B callbackasm1(SB)
MOVD $775, R12
B callbackasm1(SB)
MOVD $776, R12
B callbackasm1(SB)
MOVD $777, R12
B callbackasm1(SB)
MOVD $778, R12
B callbackasm1(SB)
MOVD $779, R12
B callbackasm1(SB)
MOVD $780, R12
B callbackasm1(SB)
MOVD $781, R12
B callbackasm1(SB)
MOVD $782, R12
B callbackasm1(SB)
MOVD $783, R12
B callbackasm1(SB)
MOVD $784, R12
B callbackasm1(SB)
MOVD $785, R12
B callbackasm1(SB)
MOVD $786, R12
B callbackasm1(SB)
MOVD $787, R12
B callbackasm1(SB)
MOVD $788, R12
B callbackasm1(SB)
MOVD $789, R12
B callbackasm1(SB)
MOVD $790, R12
B callbackasm1(SB)
MOVD $791, R12
B callbackasm1(SB)
MOVD $792, R12
B callbackasm1(SB)
MOVD $793, R12
B callbackasm1(SB)
MOVD $794, R12
B callbackasm1(SB)
MOVD $795, R12
B callbackasm1(SB)
MOVD $796, R12
B callbackasm1(SB)
MOVD $797, R12
B callbackasm1(SB)
MOVD $798, R12
B callbackasm1(SB)
MOVD $799, R12
B callbackasm1(SB)
MOVD $800, R12
B callbackasm1(SB)
MOVD $801, R12
B callbackasm1(SB)
MOVD $802, R12
B callbackasm1(SB)
MOVD $803, R12
B callbackasm1(SB)
MOVD $804, R12
B callbackasm1(SB)
MOVD $805, R12
B callbackasm1(SB)
MOVD $806, R12
B callbackasm1(SB)
MOVD $807, R12
B callbackasm1(SB)
MOVD $808, R12
B callbackasm1(SB)
MOVD $809, R12
B callbackasm1(SB)
MOVD $810, R12
B callbackasm1(SB)
MOVD $811, R12
B callbackasm1(SB)
MOVD $812, R12
B callbackasm1(SB)
MOVD $813, R12
B callbackasm1(SB)
MOVD $814, R12
B callbackasm1(SB)
MOVD $815, R12
B callbackasm1(SB)
MOVD $816, R12
B callbackasm1(SB)
MOVD $817, R12
B callbackasm1(SB)
MOVD $818, R12
B callbackasm1(SB)
MOVD $819, R12
B callbackasm1(SB)
MOVD $820, R12
B callbackasm1(SB)
MOVD $821, R12
B callbackasm1(SB)
MOVD $822, R12
B callbackasm1(SB)
MOVD $823, R12
B callbackasm1(SB)
MOVD $824, R12
B callbackasm1(SB)
MOVD $825, R12
B callbackasm1(SB)
MOVD $826, R12
B callbackasm1(SB)
MOVD $827, R12
B callbackasm1(SB)
MOVD $828, R12
B callbackasm1(SB)
MOVD $829, R12
B callbackasm1(SB)
MOVD $830, R12
B callbackasm1(SB)
MOVD $831, R12
B callbackasm1(SB)
MOVD $832, R12
B callbackasm1(SB)
MOVD $833, R12
B callbackasm1(SB)
MOVD $834, R12
B callbackasm1(SB)
MOVD $835, R12
B callbackasm1(SB)
MOVD $836, R12
B callbackasm1(SB)
MOVD $837, R12
B callbackasm1(SB)
MOVD $838, R12
B callbackasm1(SB)
MOVD $839, R12
B callbackasm1(SB)
MOVD $840, R12
B callbackasm1(SB)
MOVD $841, R12
B callbackasm1(SB)
MOVD $842, R12
B callbackasm1(SB)
MOVD $843, R12
B callbackasm1(SB)
MOVD $844, R12
B callbackasm1(SB)
MOVD $845, R12
B callbackasm1(SB)
MOVD $846, R12
B callbackasm1(SB)
MOVD $847, R12
B callbackasm1(SB)
MOVD $848, R12
B callbackasm1(SB)
MOVD $849, R12
B callbackasm1(SB)
MOVD $850, R12
B callbackasm1(SB)
MOVD $851, R12
B callbackasm1(SB)
MOVD $852, R12
B callbackasm1(SB)
MOVD $853, R12
B callbackasm1(SB)
MOVD $854, R12
B callbackasm1(SB)
MOVD $855, R12
B callbackasm1(SB)
MOVD $856, R12
B callbackasm1(SB)
MOVD $857, R12
B callbackasm1(SB)
MOVD $858, R12
B callbackasm1(SB)
MOVD $859, R12
B callbackasm1(SB)
MOVD $860, R12
B callbackasm1(SB)
MOVD $861, R12
B callbackasm1(SB)
MOVD $862, R12
B callbackasm1(SB)
MOVD $863, R12
B callbackasm1(SB)
MOVD $864, R12
B callbackasm1(SB)
MOVD $865, R12
B callbackasm1(SB)
MOVD $866, R12
B callbackasm1(SB)
MOVD $867, R12
B callbackasm1(SB)
MOVD $868, R12
B callbackasm1(SB)
MOVD $869, R12
B callbackasm1(SB)
MOVD $870, R12
B callbackasm1(SB)
MOVD $871, R12
B callbackasm1(SB)
MOVD $872, R12
B callbackasm1(SB)
MOVD $873, R12
B callbackasm1(SB)
MOVD $874, R12
B callbackasm1(SB)
MOVD $875, R12
B callbackasm1(SB)
MOVD $876, R12
B callbackasm1(SB)
MOVD $877, R12
B callbackasm1(SB)
MOVD $878, R12
B callbackasm1(SB)
MOVD $879, R12
B callbackasm1(SB)
MOVD $880, R12
B callbackasm1(SB)
MOVD $881, R12
B callbackasm1(SB)
MOVD $882, R12
B callbackasm1(SB)
MOVD $883, R12
B callbackasm1(SB)
MOVD $884, R12
B callbackasm1(SB)
MOVD $885, R12
B callbackasm1(SB)
MOVD $886, R12
B callbackasm1(SB)
MOVD $887, R12
B callbackasm1(SB)
MOVD $888, R12
B callbackasm1(SB)
MOVD $889, R12
B callbackasm1(SB)
MOVD $890, R12
B callbackasm1(SB)
MOVD $891, R12
B callbackasm1(SB)
MOVD $892, R12
B callbackasm1(SB)
MOVD $893, R12
B callbackasm1(SB)
MOVD $894, R12
B callbackasm1(SB)
MOVD $895, R12
B callbackasm1(SB)
MOVD $896, R12
B callbackasm1(SB)
MOVD $897, R12
B callbackasm1(SB)
MOVD $898, R12
B callbackasm1(SB)
MOVD $899, R12
B callbackasm1(SB)
MOVD $900, R12
B callbackasm1(SB)
MOVD $901, R12
B callbackasm1(SB)
MOVD $902, R12
B callbackasm1(SB)
MOVD $903, R12
B callbackasm1(SB)
MOVD $904, R12
B callbackasm1(SB)
MOVD $905, R12
B callbackasm1(SB)
MOVD $906, R12
B callbackasm1(SB)
MOVD $907, R12
B callbackasm1(SB)
MOVD $908, R12
B callbackasm1(SB)
MOVD $909, R12
B callbackasm1(SB)
MOVD $910, R12
B callbackasm1(SB)
MOVD $911, R12
B callbackasm1(SB)
MOVD $912, R12
B callbackasm1(SB)
MOVD $913, R12
B callbackasm1(SB)
MOVD $914, R12
B callbackasm1(SB)
MOVD $915, R12
B callbackasm1(SB)
MOVD $916, R12
B callbackasm1(SB)
MOVD $917, R12
B callbackasm1(SB)
MOVD $918, R12
B callbackasm1(SB)
MOVD $919, R12
B callbackasm1(SB)
MOVD $920, R12
B callbackasm1(SB)
MOVD $921, R12
B callbackasm1(SB)
MOVD $922, R12
B callbackasm1(SB)
MOVD $923, R12
B callbackasm1(SB)
MOVD $924, R12
B callbackasm1(SB)
MOVD $925, R12
B callbackasm1(SB)
MOVD $926, R12
B callbackasm1(SB)
MOVD $927, R12
B callbackasm1(SB)
MOVD $928, R12
B callbackasm1(SB)
MOVD $929, R12
B callbackasm1(SB)
MOVD $930, R12
B callbackasm1(SB)
MOVD $931, R12
B callbackasm1(SB)
MOVD $932, R12
B callbackasm1(SB)
MOVD $933, R12
B callbackasm1(SB)
MOVD $934, R12
B callbackasm1(SB)
MOVD $935, R12
B callbackasm1(SB)
MOVD $936, R12
B callbackasm1(SB)
MOVD $937, R12
B callbackasm1(SB)
MOVD $938, R12
B callbackasm1(SB)
MOVD $939, R12
B callbackasm1(SB)
MOVD $940, R12
B callbackasm1(SB)
MOVD $941, R12
B callbackasm1(SB)
MOVD $942, R12
B callbackasm1(SB)
MOVD $943, R12
B callbackasm1(SB)
MOVD $944, R12
B callbackasm1(SB)
MOVD $945, R12
B callbackasm1(SB)
MOVD $946, R12
B callbackasm1(SB)
MOVD $947, R12
B callbackasm1(SB)
MOVD $948, R12
B callbackasm1(SB)
MOVD $949, R12
B callbackasm1(SB)
MOVD $950, R12
B callbackasm1(SB)
MOVD $951, R12
B callbackasm1(SB)
MOVD $952, R12
B callbackasm1(SB)
MOVD $953, R12
B callbackasm1(SB)
MOVD $954, R12
B callbackasm1(SB)
MOVD $955, R12
B callbackasm1(SB)
MOVD $956, R12
B callbackasm1(SB)
MOVD $957, R12
B callbackasm1(SB)
MOVD $958, R12
B callbackasm1(SB)
MOVD $959, R12
B callbackasm1(SB)
MOVD $960, R12
B callbackasm1(SB)
MOVD $961, R12
B callbackasm1(SB)
MOVD $962, R12
B callbackasm1(SB)
MOVD $963, R12
B callbackasm1(SB)
MOVD $964, R12
B callbackasm1(SB)
MOVD $965, R12
B callbackasm1(SB)
MOVD $966, R12
B callbackasm1(SB)
MOVD $967, R12
B callbackasm1(SB)
MOVD $968, R12
B callbackasm1(SB)
MOVD $969, R12
B callbackasm1(SB)
MOVD $970, R12
B callbackasm1(SB)
MOVD $971, R12
B callbackasm1(SB)
MOVD $972, R12
B callbackasm1(SB)
MOVD $973, R12
B callbackasm1(SB)
MOVD $974, R12
B callbackasm1(SB)
MOVD $975, R12
B callbackasm1(SB)
MOVD $976, R12
B callbackasm1(SB)
MOVD $977, R12
B callbackasm1(SB)
MOVD $978, R12
B callbackasm1(SB)
MOVD $979, R12
B callbackasm1(SB)
MOVD $980, R12
B callbackasm1(SB)
MOVD $981, R12
B callbackasm1(SB)
MOVD $982, R12
B callbackasm1(SB)
MOVD $983, R12
B callbackasm1(SB)
MOVD $984, R12
B callbackasm1(SB)
MOVD $985, R12
B callbackasm1(SB)
MOVD $986, R12
B callbackasm1(SB)
MOVD $987, R12
B callbackasm1(SB)
MOVD $988, R12
B callbackasm1(SB)
MOVD $989, R12
B callbackasm1(SB)
MOVD $990, R12
B callbackasm1(SB)
MOVD $991, R12
B callbackasm1(SB)
MOVD $992, R12
B callbackasm1(SB)
MOVD $993, R12
B callbackasm1(SB)
MOVD $994, R12
B callbackasm1(SB)
MOVD $995, R12
B callbackasm1(SB)
MOVD $996, R12
B callbackasm1(SB)
MOVD $997, R12
B callbackasm1(SB)
MOVD $998, R12
B callbackasm1(SB)
MOVD $999, R12
B callbackasm1(SB)
MOVD $1000, R12
B callbackasm1(SB)
MOVD $1001, R12
B callbackasm1(SB)
MOVD $1002, R12
B callbackasm1(SB)
MOVD $1003, R12
B callbackasm1(SB)
MOVD $1004, R12
B callbackasm1(SB)
MOVD $1005, R12
B callbackasm1(SB)
MOVD $1006, R12
B callbackasm1(SB)
MOVD $1007, R12
B callbackasm1(SB)
MOVD $1008, R12
B callbackasm1(SB)
MOVD $1009, R12
B callbackasm1(SB)
MOVD $1010, R12
B callbackasm1(SB)
MOVD $1011, R12
B callbackasm1(SB)
MOVD $1012, R12
B callbackasm1(SB)
MOVD $1013, R12
B callbackasm1(SB)
MOVD $1014, R12
B callbackasm1(SB)
MOVD $1015, R12
B callbackasm1(SB)
MOVD $1016, R12
B callbackasm1(SB)
MOVD $1017, R12
B callbackasm1(SB)
MOVD $1018, R12
B callbackasm1(SB)
MOVD $1019, R12
B callbackasm1(SB)
MOVD $1020, R12
B callbackasm1(SB)
MOVD $1021, R12
B callbackasm1(SB)
MOVD $1022, R12
B callbackasm1(SB)
MOVD $1023, R12
B callbackasm1(SB)
MOVD $1024, R12
B callbackasm1(SB)
MOVD $1025, R12
B callbackasm1(SB)
MOVD $1026, R12
B callbackasm1(SB)
MOVD $1027, R12
B callbackasm1(SB)
MOVD $1028, R12
B callbackasm1(SB)
MOVD $1029, R12
B callbackasm1(SB)
MOVD $1030, R12
B callbackasm1(SB)
MOVD $1031, R12
B callbackasm1(SB)
MOVD $1032, R12
B callbackasm1(SB)
MOVD $1033, R12
B callbackasm1(SB)
MOVD $1034, R12
B callbackasm1(SB)
MOVD $1035, R12
B callbackasm1(SB)
MOVD $1036, R12
B callbackasm1(SB)
MOVD $1037, R12
B callbackasm1(SB)
MOVD $1038, R12
B callbackasm1(SB)
MOVD $1039, R12
B callbackasm1(SB)
MOVD $1040, R12
B callbackasm1(SB)
MOVD $1041, R12
B callbackasm1(SB)
MOVD $1042, R12
B callbackasm1(SB)
MOVD $1043, R12
B callbackasm1(SB)
MOVD $1044, R12
B callbackasm1(SB)
MOVD $1045, R12
B callbackasm1(SB)
MOVD $1046, R12
B callbackasm1(SB)
MOVD $1047, R12
B callbackasm1(SB)
MOVD $1048, R12
B callbackasm1(SB)
MOVD $1049, R12
B callbackasm1(SB)
MOVD $1050, R12
B callbackasm1(SB)
MOVD $1051, R12
B callbackasm1(SB)
MOVD $1052, R12
B callbackasm1(SB)
MOVD $1053, R12
B callbackasm1(SB)
MOVD $1054, R12
B callbackasm1(SB)
MOVD $1055, R12
B callbackasm1(SB)
MOVD $1056, R12
B callbackasm1(SB)
MOVD $1057, R12
B callbackasm1(SB)
MOVD $1058, R12
B callbackasm1(SB)
MOVD $1059, R12
B callbackasm1(SB)
MOVD $1060, R12
B callbackasm1(SB)
MOVD $1061, R12
B callbackasm1(SB)
MOVD $1062, R12
B callbackasm1(SB)
MOVD $1063, R12
B callbackasm1(SB)
MOVD $1064, R12
B callbackasm1(SB)
MOVD $1065, R12
B callbackasm1(SB)
MOVD $1066, R12
B callbackasm1(SB)
MOVD $1067, R12
B callbackasm1(SB)
MOVD $1068, R12
B callbackasm1(SB)
MOVD $1069, R12
B callbackasm1(SB)
MOVD $1070, R12
B callbackasm1(SB)
MOVD $1071, R12
B callbackasm1(SB)
MOVD $1072, R12
B callbackasm1(SB)
MOVD $1073, R12
B callbackasm1(SB)
MOVD $1074, R12
B callbackasm1(SB)
MOVD $1075, R12
B callbackasm1(SB)
MOVD $1076, R12
B callbackasm1(SB)
MOVD $1077, R12
B callbackasm1(SB)
MOVD $1078, R12
B callbackasm1(SB)
MOVD $1079, R12
B callbackasm1(SB)
MOVD $1080, R12
B callbackasm1(SB)
MOVD $1081, R12
B callbackasm1(SB)
MOVD $1082, R12
B callbackasm1(SB)
MOVD $1083, R12
B callbackasm1(SB)
MOVD $1084, R12
B callbackasm1(SB)
MOVD $1085, R12
B callbackasm1(SB)
MOVD $1086, R12
B callbackasm1(SB)
MOVD $1087, R12
B callbackasm1(SB)
MOVD $1088, R12
B callbackasm1(SB)
MOVD $1089, R12
B callbackasm1(SB)
MOVD $1090, R12
B callbackasm1(SB)
MOVD $1091, R12
B callbackasm1(SB)
MOVD $1092, R12
B callbackasm1(SB)
MOVD $1093, R12
B callbackasm1(SB)
MOVD $1094, R12
B callbackasm1(SB)
MOVD $1095, R12
B callbackasm1(SB)
MOVD $1096, R12
B callbackasm1(SB)
MOVD $1097, R12
B callbackasm1(SB)
MOVD $1098, R12
B callbackasm1(SB)
MOVD $1099, R12
B callbackasm1(SB)
MOVD $1100, R12
B callbackasm1(SB)
MOVD $1101, R12
B callbackasm1(SB)
MOVD $1102, R12
B callbackasm1(SB)
MOVD $1103, R12
B callbackasm1(SB)
MOVD $1104, R12
B callbackasm1(SB)
MOVD $1105, R12
B callbackasm1(SB)
MOVD $1106, R12
B callbackasm1(SB)
MOVD $1107, R12
B callbackasm1(SB)
MOVD $1108, R12
B callbackasm1(SB)
MOVD $1109, R12
B callbackasm1(SB)
MOVD $1110, R12
B callbackasm1(SB)
MOVD $1111, R12
B callbackasm1(SB)
MOVD $1112, R12
B callbackasm1(SB)
MOVD $1113, R12
B callbackasm1(SB)
MOVD $1114, R12
B callbackasm1(SB)
MOVD $1115, R12
B callbackasm1(SB)
MOVD $1116, R12
B callbackasm1(SB)
MOVD $1117, R12
B callbackasm1(SB)
MOVD $1118, R12
B callbackasm1(SB)
MOVD $1119, R12
B callbackasm1(SB)
MOVD $1120, R12
B callbackasm1(SB)
MOVD $1121, R12
B callbackasm1(SB)
MOVD $1122, R12
B callbackasm1(SB)
MOVD $1123, R12
B callbackasm1(SB)
MOVD $1124, R12
B callbackasm1(SB)
MOVD $1125, R12
B callbackasm1(SB)
MOVD $1126, R12
B callbackasm1(SB)
MOVD $1127, R12
B callbackasm1(SB)
MOVD $1128, R12
B callbackasm1(SB)
MOVD $1129, R12
B callbackasm1(SB)
MOVD $1130, R12
B callbackasm1(SB)
MOVD $1131, R12
B callbackasm1(SB)
MOVD $1132, R12
B callbackasm1(SB)
MOVD $1133, R12
B callbackasm1(SB)
MOVD $1134, R12
B callbackasm1(SB)
MOVD $1135, R12
B callbackasm1(SB)
MOVD $1136, R12
B callbackasm1(SB)
MOVD $1137, R12
B callbackasm1(SB)
MOVD $1138, R12
B callbackasm1(SB)
MOVD $1139, R12
B callbackasm1(SB)
MOVD $1140, R12
B callbackasm1(SB)
MOVD $1141, R12
B callbackasm1(SB)
MOVD $1142, R12
B callbackasm1(SB)
MOVD $1143, R12
B callbackasm1(SB)
MOVD $1144, R12
B callbackasm1(SB)
MOVD $1145, R12
B callbackasm1(SB)
MOVD $1146, R12
B callbackasm1(SB)
MOVD $1147, R12
B callbackasm1(SB)
MOVD $1148, R12
B callbackasm1(SB)
MOVD $1149, R12
B callbackasm1(SB)
MOVD $1150, R12
B callbackasm1(SB)
MOVD $1151, R12
B callbackasm1(SB)
MOVD $1152, R12
B callbackasm1(SB)
MOVD $1153, R12
B callbackasm1(SB)
MOVD $1154, R12
B callbackasm1(SB)
MOVD $1155, R12
B callbackasm1(SB)
MOVD $1156, R12
B callbackasm1(SB)
MOVD $1157, R12
B callbackasm1(SB)
MOVD $1158, R12
B callbackasm1(SB)
MOVD $1159, R12
B callbackasm1(SB)
MOVD $1160, R12
B callbackasm1(SB)
MOVD $1161, R12
B callbackasm1(SB)
MOVD $1162, R12
B callbackasm1(SB)
MOVD $1163, R12
B callbackasm1(SB)
MOVD $1164, R12
B callbackasm1(SB)
MOVD $1165, R12
B callbackasm1(SB)
MOVD $1166, R12
B callbackasm1(SB)
MOVD $1167, R12
B callbackasm1(SB)
MOVD $1168, R12
B callbackasm1(SB)
MOVD $1169, R12
B callbackasm1(SB)
MOVD $1170, R12
B callbackasm1(SB)
MOVD $1171, R12
B callbackasm1(SB)
MOVD $1172, R12
B callbackasm1(SB)
MOVD $1173, R12
B callbackasm1(SB)
MOVD $1174, R12
B callbackasm1(SB)
MOVD $1175, R12
B callbackasm1(SB)
MOVD $1176, R12
B callbackasm1(SB)
MOVD $1177, R12
B callbackasm1(SB)
MOVD $1178, R12
B callbackasm1(SB)
MOVD $1179, R12
B callbackasm1(SB)
MOVD $1180, R12
B callbackasm1(SB)
MOVD $1181, R12
B callbackasm1(SB)
MOVD $1182, R12
B callbackasm1(SB)
MOVD $1183, R12
B callbackasm1(SB)
MOVD $1184, R12
B callbackasm1(SB)
MOVD $1185, R12
B callbackasm1(SB)
MOVD $1186, R12
B callbackasm1(SB)
MOVD $1187, R12
B callbackasm1(SB)
MOVD $1188, R12
B callbackasm1(SB)
MOVD $1189, R12
B callbackasm1(SB)
MOVD $1190, R12
B callbackasm1(SB)
MOVD $1191, R12
B callbackasm1(SB)
MOVD $1192, R12
B callbackasm1(SB)
MOVD $1193, R12
B callbackasm1(SB)
MOVD $1194, R12
B callbackasm1(SB)
MOVD $1195, R12
B callbackasm1(SB)
MOVD $1196, R12
B callbackasm1(SB)
MOVD $1197, R12
B callbackasm1(SB)
MOVD $1198, R12
B callbackasm1(SB)
MOVD $1199, R12
B callbackasm1(SB)
MOVD $1200, R12
B callbackasm1(SB)
MOVD $1201, R12
B callbackasm1(SB)
MOVD $1202, R12
B callbackasm1(SB)
MOVD $1203, R12
B callbackasm1(SB)
MOVD $1204, R12
B callbackasm1(SB)
MOVD $1205, R12
B callbackasm1(SB)
MOVD $1206, R12
B callbackasm1(SB)
MOVD $1207, R12
B callbackasm1(SB)
MOVD $1208, R12
B callbackasm1(SB)
MOVD $1209, R12
B callbackasm1(SB)
MOVD $1210, R12
B callbackasm1(SB)
MOVD $1211, R12
B callbackasm1(SB)
MOVD $1212, R12
B callbackasm1(SB)
MOVD $1213, R12
B callbackasm1(SB)
MOVD $1214, R12
B callbackasm1(SB)
MOVD $1215, R12
B callbackasm1(SB)
MOVD $1216, R12
B callbackasm1(SB)
MOVD $1217, R12
B callbackasm1(SB)
MOVD $1218, R12
B callbackasm1(SB)
MOVD $1219, R12
B callbackasm1(SB)
MOVD $1220, R12
B callbackasm1(SB)
MOVD $1221, R12
B callbackasm1(SB)
MOVD $1222, R12
B callbackasm1(SB)
MOVD $1223, R12
B callbackasm1(SB)
MOVD $1224, R12
B callbackasm1(SB)
MOVD $1225, R12
B callbackasm1(SB)
MOVD $1226, R12
B callbackasm1(SB)
MOVD $1227, R12
B callbackasm1(SB)
MOVD $1228, R12
B callbackasm1(SB)
MOVD $1229, R12
B callbackasm1(SB)
MOVD $1230, R12
B callbackasm1(SB)
MOVD $1231, R12
B callbackasm1(SB)
MOVD $1232, R12
B callbackasm1(SB)
MOVD $1233, R12
B callbackasm1(SB)
MOVD $1234, R12
B callbackasm1(SB)
MOVD $1235, R12
B callbackasm1(SB)
MOVD $1236, R12
B callbackasm1(SB)
MOVD $1237, R12
B callbackasm1(SB)
MOVD $1238, R12
B callbackasm1(SB)
MOVD $1239, R12
B callbackasm1(SB)
MOVD $1240, R12
B callbackasm1(SB)
MOVD $1241, R12
B callbackasm1(SB)
MOVD $1242, R12
B callbackasm1(SB)
MOVD $1243, R12
B callbackasm1(SB)
MOVD $1244, R12
B callbackasm1(SB)
MOVD $1245, R12
B callbackasm1(SB)
MOVD $1246, R12
B callbackasm1(SB)
MOVD $1247, R12
B callbackasm1(SB)
MOVD $1248, R12
B callbackasm1(SB)
MOVD $1249, R12
B callbackasm1(SB)
MOVD $1250, R12
B callbackasm1(SB)
MOVD $1251, R12
B callbackasm1(SB)
MOVD $1252, R12
B callbackasm1(SB)
MOVD $1253, R12
B callbackasm1(SB)
MOVD $1254, R12
B callbackasm1(SB)
MOVD $1255, R12
B callbackasm1(SB)
MOVD $1256, R12
B callbackasm1(SB)
MOVD $1257, R12
B callbackasm1(SB)
MOVD $1258, R12
B callbackasm1(SB)
MOVD $1259, R12
B callbackasm1(SB)
MOVD $1260, R12
B callbackasm1(SB)
MOVD $1261, R12
B callbackasm1(SB)
MOVD $1262, R12
B callbackasm1(SB)
MOVD $1263, R12
B callbackasm1(SB)
MOVD $1264, R12
B callbackasm1(SB)
MOVD $1265, R12
B callbackasm1(SB)
MOVD $1266, R12
B callbackasm1(SB)
MOVD $1267, R12
B callbackasm1(SB)
MOVD $1268, R12
B callbackasm1(SB)
MOVD $1269, R12
B callbackasm1(SB)
MOVD $1270, R12
B callbackasm1(SB)
MOVD $1271, R12
B callbackasm1(SB)
MOVD $1272, R12
B callbackasm1(SB)
MOVD $1273, R12
B callbackasm1(SB)
MOVD $1274, R12
B callbackasm1(SB)
MOVD $1275, R12
B callbackasm1(SB)
MOVD $1276, R12
B callbackasm1(SB)
MOVD $1277, R12
B callbackasm1(SB)
MOVD $1278, R12
B callbackasm1(SB)
MOVD $1279, R12
B callbackasm1(SB)
MOVD $1280, R12
B callbackasm1(SB)
MOVD $1281, R12
B callbackasm1(SB)
MOVD $1282, R12
B callbackasm1(SB)
MOVD $1283, R12
B callbackasm1(SB)
MOVD $1284, R12
B callbackasm1(SB)
MOVD $1285, R12
B callbackasm1(SB)
MOVD $1286, R12
B callbackasm1(SB)
MOVD $1287, R12
B callbackasm1(SB)
MOVD $1288, R12
B callbackasm1(SB)
MOVD $1289, R12
B callbackasm1(SB)
MOVD $1290, R12
B callbackasm1(SB)
MOVD $1291, R12
B callbackasm1(SB)
MOVD $1292, R12
B callbackasm1(SB)
MOVD $1293, R12
B callbackasm1(SB)
MOVD $1294, R12
B callbackasm1(SB)
MOVD $1295, R12
B callbackasm1(SB)
MOVD $1296, R12
B callbackasm1(SB)
MOVD $1297, R12
B callbackasm1(SB)
MOVD $1298, R12
B callbackasm1(SB)
MOVD $1299, R12
B callbackasm1(SB)
MOVD $1300, R12
B callbackasm1(SB)
MOVD $1301, R12
B callbackasm1(SB)
MOVD $1302, R12
B callbackasm1(SB)
MOVD $1303, R12
B callbackasm1(SB)
MOVD $1304, R12
B callbackasm1(SB)
MOVD $1305, R12
B callbackasm1(SB)
MOVD $1306, R12
B callbackasm1(SB)
MOVD $1307, R12
B callbackasm1(SB)
MOVD $1308, R12
B callbackasm1(SB)
MOVD $1309, R12
B callbackasm1(SB)
MOVD $1310, R12
B callbackasm1(SB)
MOVD $1311, R12
B callbackasm1(SB)
MOVD $1312, R12
B callbackasm1(SB)
MOVD $1313, R12
B callbackasm1(SB)
MOVD $1314, R12
B callbackasm1(SB)
MOVD $1315, R12
B callbackasm1(SB)
MOVD $1316, R12
B callbackasm1(SB)
MOVD $1317, R12
B callbackasm1(SB)
MOVD $1318, R12
B callbackasm1(SB)
MOVD $1319, R12
B callbackasm1(SB)
MOVD $1320, R12
B callbackasm1(SB)
MOVD $1321, R12
B callbackasm1(SB)
MOVD $1322, R12
B callbackasm1(SB)
MOVD $1323, R12
B callbackasm1(SB)
MOVD $1324, R12
B callbackasm1(SB)
MOVD $1325, R12
B callbackasm1(SB)
MOVD $1326, R12
B callbackasm1(SB)
MOVD $1327, R12
B callbackasm1(SB)
MOVD $1328, R12
B callbackasm1(SB)
MOVD $1329, R12
B callbackasm1(SB)
MOVD $1330, R12
B callbackasm1(SB)
MOVD $1331, R12
B callbackasm1(SB)
MOVD $1332, R12
B callbackasm1(SB)
MOVD $1333, R12
B callbackasm1(SB)
MOVD $1334, R12
B callbackasm1(SB)
MOVD $1335, R12
B callbackasm1(SB)
MOVD $1336, R12
B callbackasm1(SB)
MOVD $1337, R12
B callbackasm1(SB)
MOVD $1338, R12
B callbackasm1(SB)
MOVD $1339, R12
B callbackasm1(SB)
MOVD $1340, R12
B callbackasm1(SB)
MOVD $1341, R12
B callbackasm1(SB)
MOVD $1342, R12
B callbackasm1(SB)
MOVD $1343, R12
B callbackasm1(SB)
MOVD $1344, R12
B callbackasm1(SB)
MOVD $1345, R12
B callbackasm1(SB)
MOVD $1346, R12
B callbackasm1(SB)
MOVD $1347, R12
B callbackasm1(SB)
MOVD $1348, R12
B callbackasm1(SB)
MOVD $1349, R12
B callbackasm1(SB)
MOVD $1350, R12
B callbackasm1(SB)
MOVD $1351, R12
B callbackasm1(SB)
MOVD $1352, R12
B callbackasm1(SB)
MOVD $1353, R12
B callbackasm1(SB)
MOVD $1354, R12
B callbackasm1(SB)
MOVD $1355, R12
B callbackasm1(SB)
MOVD $1356, R12
B callbackasm1(SB)
MOVD $1357, R12
B callbackasm1(SB)
MOVD $1358, R12
B callbackasm1(SB)
MOVD $1359, R12
B callbackasm1(SB)
MOVD $1360, R12
B callbackasm1(SB)
MOVD $1361, R12
B callbackasm1(SB)
MOVD $1362, R12
B callbackasm1(SB)
MOVD $1363, R12
B callbackasm1(SB)
MOVD $1364, R12
B callbackasm1(SB)
MOVD $1365, R12
B callbackasm1(SB)
MOVD $1366, R12
B callbackasm1(SB)
MOVD $1367, R12
B callbackasm1(SB)
MOVD $1368, R12
B callbackasm1(SB)
MOVD $1369, R12
B callbackasm1(SB)
MOVD $1370, R12
B callbackasm1(SB)
MOVD $1371, R12
B callbackasm1(SB)
MOVD $1372, R12
B callbackasm1(SB)
MOVD $1373, R12
B callbackasm1(SB)
MOVD $1374, R12
B callbackasm1(SB)
MOVD $1375, R12
B callbackasm1(SB)
MOVD $1376, R12
B callbackasm1(SB)
MOVD $1377, R12
B callbackasm1(SB)
MOVD $1378, R12
B callbackasm1(SB)
MOVD $1379, R12
B callbackasm1(SB)
MOVD $1380, R12
B callbackasm1(SB)
MOVD $1381, R12
B callbackasm1(SB)
MOVD $1382, R12
B callbackasm1(SB)
MOVD $1383, R12
B callbackasm1(SB)
MOVD $1384, R12
B callbackasm1(SB)
MOVD $1385, R12
B callbackasm1(SB)
MOVD $1386, R12
B callbackasm1(SB)
MOVD $1387, R12
B callbackasm1(SB)
MOVD $1388, R12
B callbackasm1(SB)
MOVD $1389, R12
B callbackasm1(SB)
MOVD $1390, R12
B callbackasm1(SB)
MOVD $1391, R12
B callbackasm1(SB)
MOVD $1392, R12
B callbackasm1(SB)
MOVD $1393, R12
B callbackasm1(SB)
MOVD $1394, R12
B callbackasm1(SB)
MOVD $1395, R12
B callbackasm1(SB)
MOVD $1396, R12
B callbackasm1(SB)
MOVD $1397, R12
B callbackasm1(SB)
MOVD $1398, R12
B callbackasm1(SB)
MOVD $1399, R12
B callbackasm1(SB)
MOVD $1400, R12
B callbackasm1(SB)
MOVD $1401, R12
B callbackasm1(SB)
MOVD $1402, R12
B callbackasm1(SB)
MOVD $1403, R12
B callbackasm1(SB)
MOVD $1404, R12
B callbackasm1(SB)
MOVD $1405, R12
B callbackasm1(SB)
MOVD $1406, R12
B callbackasm1(SB)
MOVD $1407, R12
B callbackasm1(SB)
MOVD $1408, R12
B callbackasm1(SB)
MOVD $1409, R12
B callbackasm1(SB)
MOVD $1410, R12
B callbackasm1(SB)
MOVD $1411, R12
B callbackasm1(SB)
MOVD $1412, R12
B callbackasm1(SB)
MOVD $1413, R12
B callbackasm1(SB)
MOVD $1414, R12
B callbackasm1(SB)
MOVD $1415, R12
B callbackasm1(SB)
MOVD $1416, R12
B callbackasm1(SB)
MOVD $1417, R12
B callbackasm1(SB)
MOVD $1418, R12
B callbackasm1(SB)
MOVD $1419, R12
B callbackasm1(SB)
MOVD $1420, R12
B callbackasm1(SB)
MOVD $1421, R12
B callbackasm1(SB)
MOVD $1422, R12
B callbackasm1(SB)
MOVD $1423, R12
B callbackasm1(SB)
MOVD $1424, R12
B callbackasm1(SB)
MOVD $1425, R12
B callbackasm1(SB)
MOVD $1426, R12
B callbackasm1(SB)
MOVD $1427, R12
B callbackasm1(SB)
MOVD $1428, R12
B callbackasm1(SB)
MOVD $1429, R12
B callbackasm1(SB)
MOVD $1430, R12
B callbackasm1(SB)
MOVD $1431, R12
B callbackasm1(SB)
MOVD $1432, R12
B callbackasm1(SB)
MOVD $1433, R12
B callbackasm1(SB)
MOVD $1434, R12
B callbackasm1(SB)
MOVD $1435, R12
B callbackasm1(SB)
MOVD $1436, R12
B callbackasm1(SB)
MOVD $1437, R12
B callbackasm1(SB)
MOVD $1438, R12
B callbackasm1(SB)
MOVD $1439, R12
B callbackasm1(SB)
MOVD $1440, R12
B callbackasm1(SB)
MOVD $1441, R12
B callbackasm1(SB)
MOVD $1442, R12
B callbackasm1(SB)
MOVD $1443, R12
B callbackasm1(SB)
MOVD $1444, R12
B callbackasm1(SB)
MOVD $1445, R12
B callbackasm1(SB)
MOVD $1446, R12
B callbackasm1(SB)
MOVD $1447, R12
B callbackasm1(SB)
MOVD $1448, R12
B callbackasm1(SB)
MOVD $1449, R12
B callbackasm1(SB)
MOVD $1450, R12
B callbackasm1(SB)
MOVD $1451, R12
B callbackasm1(SB)
MOVD $1452, R12
B callbackasm1(SB)
MOVD $1453, R12
B callbackasm1(SB)
MOVD $1454, R12
B callbackasm1(SB)
MOVD $1455, R12
B callbackasm1(SB)
MOVD $1456, R12
B callbackasm1(SB)
MOVD $1457, R12
B callbackasm1(SB)
MOVD $1458, R12
B callbackasm1(SB)
MOVD $1459, R12
B callbackasm1(SB)
MOVD $1460, R12
B callbackasm1(SB)
MOVD $1461, R12
B callbackasm1(SB)
MOVD $1462, R12
B callbackasm1(SB)
MOVD $1463, R12
B callbackasm1(SB)
MOVD $1464, R12
B callbackasm1(SB)
MOVD $1465, R12
B callbackasm1(SB)
MOVD $1466, R12
B callbackasm1(SB)
MOVD $1467, R12
B callbackasm1(SB)
MOVD $1468, R12
B callbackasm1(SB)
MOVD $1469, R12
B callbackasm1(SB)
MOVD $1470, R12
B callbackasm1(SB)
MOVD $1471, R12
B callbackasm1(SB)
MOVD $1472, R12
B callbackasm1(SB)
MOVD $1473, R12
B callbackasm1(SB)
MOVD $1474, R12
B callbackasm1(SB)
MOVD $1475, R12
B callbackasm1(SB)
MOVD $1476, R12
B callbackasm1(SB)
MOVD $1477, R12
B callbackasm1(SB)
MOVD $1478, R12
B callbackasm1(SB)
MOVD $1479, R12
B callbackasm1(SB)
MOVD $1480, R12
B callbackasm1(SB)
MOVD $1481, R12
B callbackasm1(SB)
MOVD $1482, R12
B callbackasm1(SB)
MOVD $1483, R12
B callbackasm1(SB)
MOVD $1484, R12
B callbackasm1(SB)
MOVD $1485, R12
B callbackasm1(SB)
MOVD $1486, R12
B callbackasm1(SB)
MOVD $1487, R12
B callbackasm1(SB)
MOVD $1488, R12
B callbackasm1(SB)
MOVD $1489, R12
B callbackasm1(SB)
MOVD $1490, R12
B callbackasm1(SB)
MOVD $1491, R12
B callbackasm1(SB)
MOVD $1492, R12
B callbackasm1(SB)
MOVD $1493, R12
B callbackasm1(SB)
MOVD $1494, R12
B callbackasm1(SB)
MOVD $1495, R12
B callbackasm1(SB)
MOVD $1496, R12
B callbackasm1(SB)
MOVD $1497, R12
B callbackasm1(SB)
MOVD $1498, R12
B callbackasm1(SB)
MOVD $1499, R12
B callbackasm1(SB)
MOVD $1500, R12
B callbackasm1(SB)
MOVD $1501, R12
B callbackasm1(SB)
MOVD $1502, R12
B callbackasm1(SB)
MOVD $1503, R12
B callbackasm1(SB)
MOVD $1504, R12
B callbackasm1(SB)
MOVD $1505, R12
B callbackasm1(SB)
MOVD $1506, R12
B callbackasm1(SB)
MOVD $1507, R12
B callbackasm1(SB)
MOVD $1508, R12
B callbackasm1(SB)
MOVD $1509, R12
B callbackasm1(SB)
MOVD $1510, R12
B callbackasm1(SB)
MOVD $1511, R12
B callbackasm1(SB)
MOVD $1512, R12
B callbackasm1(SB)
MOVD $1513, R12
B callbackasm1(SB)
MOVD $1514, R12
B callbackasm1(SB)
MOVD $1515, R12
B callbackasm1(SB)
MOVD $1516, R12
B callbackasm1(SB)
MOVD $1517, R12
B callbackasm1(SB)
MOVD $1518, R12
B callbackasm1(SB)
MOVD $1519, R12
B callbackasm1(SB)
MOVD $1520, R12
B callbackasm1(SB)
MOVD $1521, R12
B callbackasm1(SB)
MOVD $1522, R12
B callbackasm1(SB)
MOVD $1523, R12
B callbackasm1(SB)
MOVD $1524, R12
B callbackasm1(SB)
MOVD $1525, R12
B callbackasm1(SB)
MOVD $1526, R12
B callbackasm1(SB)
MOVD $1527, R12
B callbackasm1(SB)
MOVD $1528, R12
B callbackasm1(SB)
MOVD $1529, R12
B callbackasm1(SB)
MOVD $1530, R12
B callbackasm1(SB)
MOVD $1531, R12
B callbackasm1(SB)
MOVD $1532, R12
B callbackasm1(SB)
MOVD $1533, R12
B callbackasm1(SB)
MOVD $1534, R12
B callbackasm1(SB)
MOVD $1535, R12
B callbackasm1(SB)
MOVD $1536, R12
B callbackasm1(SB)
MOVD $1537, R12
B callbackasm1(SB)
MOVD $1538, R12
B callbackasm1(SB)
MOVD $1539, R12
B callbackasm1(SB)
MOVD $1540, R12
B callbackasm1(SB)
MOVD $1541, R12
B callbackasm1(SB)
MOVD $1542, R12
B callbackasm1(SB)
MOVD $1543, R12
B callbackasm1(SB)
MOVD $1544, R12
B callbackasm1(SB)
MOVD $1545, R12
B callbackasm1(SB)
MOVD $1546, R12
B callbackasm1(SB)
MOVD $1547, R12
B callbackasm1(SB)
MOVD $1548, R12
B callbackasm1(SB)
MOVD $1549, R12
B callbackasm1(SB)
MOVD $1550, R12
B callbackasm1(SB)
MOVD $1551, R12
B callbackasm1(SB)
MOVD $1552, R12
B callbackasm1(SB)
MOVD $1553, R12
B callbackasm1(SB)
MOVD $1554, R12
B callbackasm1(SB)
MOVD $1555, R12
B callbackasm1(SB)
MOVD $1556, R12
B callbackasm1(SB)
MOVD $1557, R12
B callbackasm1(SB)
MOVD $1558, R12
B callbackasm1(SB)
MOVD $1559, R12
B callbackasm1(SB)
MOVD $1560, R12
B callbackasm1(SB)
MOVD $1561, R12
B callbackasm1(SB)
MOVD $1562, R12
B callbackasm1(SB)
MOVD $1563, R12
B callbackasm1(SB)
MOVD $1564, R12
B callbackasm1(SB)
MOVD $1565, R12
B callbackasm1(SB)
MOVD $1566, R12
B callbackasm1(SB)
MOVD $1567, R12
B callbackasm1(SB)
MOVD $1568, R12
B callbackasm1(SB)
MOVD $1569, R12
B callbackasm1(SB)
MOVD $1570, R12
B callbackasm1(SB)
MOVD $1571, R12
B callbackasm1(SB)
MOVD $1572, R12
B callbackasm1(SB)
MOVD $1573, R12
B callbackasm1(SB)
MOVD $1574, R12
B callbackasm1(SB)
MOVD $1575, R12
B callbackasm1(SB)
MOVD $1576, R12
B callbackasm1(SB)
MOVD $1577, R12
B callbackasm1(SB)
MOVD $1578, R12
B callbackasm1(SB)
MOVD $1579, R12
B callbackasm1(SB)
MOVD $1580, R12
B callbackasm1(SB)
MOVD $1581, R12
B callbackasm1(SB)
MOVD $1582, R12
B callbackasm1(SB)
MOVD $1583, R12
B callbackasm1(SB)
MOVD $1584, R12
B callbackasm1(SB)
MOVD $1585, R12
B callbackasm1(SB)
MOVD $1586, R12
B callbackasm1(SB)
MOVD $1587, R12
B callbackasm1(SB)
MOVD $1588, R12
B callbackasm1(SB)
MOVD $1589, R12
B callbackasm1(SB)
MOVD $1590, R12
B callbackasm1(SB)
MOVD $1591, R12
B callbackasm1(SB)
MOVD $1592, R12
B callbackasm1(SB)
MOVD $1593, R12
B callbackasm1(SB)
MOVD $1594, R12
B callbackasm1(SB)
MOVD $1595, R12
B callbackasm1(SB)
MOVD $1596, R12
B callbackasm1(SB)
MOVD $1597, R12
B callbackasm1(SB)
MOVD $1598, R12
B callbackasm1(SB)
MOVD $1599, R12
B callbackasm1(SB)
MOVD $1600, R12
B callbackasm1(SB)
MOVD $1601, R12
B callbackasm1(SB)
MOVD $1602, R12
B callbackasm1(SB)
MOVD $1603, R12
B callbackasm1(SB)
MOVD $1604, R12
B callbackasm1(SB)
MOVD $1605, R12
B callbackasm1(SB)
MOVD $1606, R12
B callbackasm1(SB)
MOVD $1607, R12
B callbackasm1(SB)
MOVD $1608, R12
B callbackasm1(SB)
MOVD $1609, R12
B callbackasm1(SB)
MOVD $1610, R12
B callbackasm1(SB)
MOVD $1611, R12
B callbackasm1(SB)
MOVD $1612, R12
B callbackasm1(SB)
MOVD $1613, R12
B callbackasm1(SB)
MOVD $1614, R12
B callbackasm1(SB)
MOVD $1615, R12
B callbackasm1(SB)
MOVD $1616, R12
B callbackasm1(SB)
MOVD $1617, R12
B callbackasm1(SB)
MOVD $1618, R12
B callbackasm1(SB)
MOVD $1619, R12
B callbackasm1(SB)
MOVD $1620, R12
B callbackasm1(SB)
MOVD $1621, R12
B callbackasm1(SB)
MOVD $1622, R12
B callbackasm1(SB)
MOVD $1623, R12
B callbackasm1(SB)
MOVD $1624, R12
B callbackasm1(SB)
MOVD $1625, R12
B callbackasm1(SB)
MOVD $1626, R12
B callbackasm1(SB)
MOVD $1627, R12
B callbackasm1(SB)
MOVD $1628, R12
B callbackasm1(SB)
MOVD $1629, R12
B callbackasm1(SB)
MOVD $1630, R12
B callbackasm1(SB)
MOVD $1631, R12
B callbackasm1(SB)
MOVD $1632, R12
B callbackasm1(SB)
MOVD $1633, R12
B callbackasm1(SB)
MOVD $1634, R12
B callbackasm1(SB)
MOVD $1635, R12
B callbackasm1(SB)
MOVD $1636, R12
B callbackasm1(SB)
MOVD $1637, R12
B callbackasm1(SB)
MOVD $1638, R12
B callbackasm1(SB)
MOVD $1639, R12
B callbackasm1(SB)
MOVD $1640, R12
B callbackasm1(SB)
MOVD $1641, R12
B callbackasm1(SB)
MOVD $1642, R12
B callbackasm1(SB)
MOVD $1643, R12
B callbackasm1(SB)
MOVD $1644, R12
B callbackasm1(SB)
MOVD $1645, R12
B callbackasm1(SB)
MOVD $1646, R12
B callbackasm1(SB)
MOVD $1647, R12
B callbackasm1(SB)
MOVD $1648, R12
B callbackasm1(SB)
MOVD $1649, R12
B callbackasm1(SB)
MOVD $1650, R12
B callbackasm1(SB)
MOVD $1651, R12
B callbackasm1(SB)
MOVD $1652, R12
B callbackasm1(SB)
MOVD $1653, R12
B callbackasm1(SB)
MOVD $1654, R12
B callbackasm1(SB)
MOVD $1655, R12
B callbackasm1(SB)
MOVD $1656, R12
B callbackasm1(SB)
MOVD $1657, R12
B callbackasm1(SB)
MOVD $1658, R12
B callbackasm1(SB)
MOVD $1659, R12
B callbackasm1(SB)
MOVD $1660, R12
B callbackasm1(SB)
MOVD $1661, R12
B callbackasm1(SB)
MOVD $1662, R12
B callbackasm1(SB)
MOVD $1663, R12
B callbackasm1(SB)
MOVD $1664, R12
B callbackasm1(SB)
MOVD $1665, R12
B callbackasm1(SB)
MOVD $1666, R12
B callbackasm1(SB)
MOVD $1667, R12
B callbackasm1(SB)
MOVD $1668, R12
B callbackasm1(SB)
MOVD $1669, R12
B callbackasm1(SB)
MOVD $1670, R12
B callbackasm1(SB)
MOVD $1671, R12
B callbackasm1(SB)
MOVD $1672, R12
B callbackasm1(SB)
MOVD $1673, R12
B callbackasm1(SB)
MOVD $1674, R12
B callbackasm1(SB)
MOVD $1675, R12
B callbackasm1(SB)
MOVD $1676, R12
B callbackasm1(SB)
MOVD $1677, R12
B callbackasm1(SB)
MOVD $1678, R12
B callbackasm1(SB)
MOVD $1679, R12
B callbackasm1(SB)
MOVD $1680, R12
B callbackasm1(SB)
MOVD $1681, R12
B callbackasm1(SB)
MOVD $1682, R12
B callbackasm1(SB)
MOVD $1683, R12
B callbackasm1(SB)
MOVD $1684, R12
B callbackasm1(SB)
MOVD $1685, R12
B callbackasm1(SB)
MOVD $1686, R12
B callbackasm1(SB)
MOVD $1687, R12
B callbackasm1(SB)
MOVD $1688, R12
B callbackasm1(SB)
MOVD $1689, R12
B callbackasm1(SB)
MOVD $1690, R12
B callbackasm1(SB)
MOVD $1691, R12
B callbackasm1(SB)
MOVD $1692, R12
B callbackasm1(SB)
MOVD $1693, R12
B callbackasm1(SB)
MOVD $1694, R12
B callbackasm1(SB)
MOVD $1695, R12
B callbackasm1(SB)
MOVD $1696, R12
B callbackasm1(SB)
MOVD $1697, R12
B callbackasm1(SB)
MOVD $1698, R12
B callbackasm1(SB)
MOVD $1699, R12
B callbackasm1(SB)
MOVD $1700, R12
B callbackasm1(SB)
MOVD $1701, R12
B callbackasm1(SB)
MOVD $1702, R12
B callbackasm1(SB)
MOVD $1703, R12
B callbackasm1(SB)
MOVD $1704, R12
B callbackasm1(SB)
MOVD $1705, R12
B callbackasm1(SB)
MOVD $1706, R12
B callbackasm1(SB)
MOVD $1707, R12
B callbackasm1(SB)
MOVD $1708, R12
B callbackasm1(SB)
MOVD $1709, R12
B callbackasm1(SB)
MOVD $1710, R12
B callbackasm1(SB)
MOVD $1711, R12
B callbackasm1(SB)
MOVD $1712, R12
B callbackasm1(SB)
MOVD $1713, R12
B callbackasm1(SB)
MOVD $1714, R12
B callbackasm1(SB)
MOVD $1715, R12
B callbackasm1(SB)
MOVD $1716, R12
B callbackasm1(SB)
MOVD $1717, R12
B callbackasm1(SB)
MOVD $1718, R12
B callbackasm1(SB)
MOVD $1719, R12
B callbackasm1(SB)
MOVD $1720, R12
B callbackasm1(SB)
MOVD $1721, R12
B callbackasm1(SB)
MOVD $1722, R12
B callbackasm1(SB)
MOVD $1723, R12
B callbackasm1(SB)
MOVD $1724, R12
B callbackasm1(SB)
MOVD $1725, R12
B callbackasm1(SB)
MOVD $1726, R12
B callbackasm1(SB)
MOVD $1727, R12
B callbackasm1(SB)
MOVD $1728, R12
B callbackasm1(SB)
MOVD $1729, R12
B callbackasm1(SB)
MOVD $1730, R12
B callbackasm1(SB)
MOVD $1731, R12
B callbackasm1(SB)
MOVD $1732, R12
B callbackasm1(SB)
MOVD $1733, R12
B callbackasm1(SB)
MOVD $1734, R12
B callbackasm1(SB)
MOVD $1735, R12
B callbackasm1(SB)
MOVD $1736, R12
B callbackasm1(SB)
MOVD $1737, R12
B callbackasm1(SB)
MOVD $1738, R12
B callbackasm1(SB)
MOVD $1739, R12
B callbackasm1(SB)
MOVD $1740, R12
B callbackasm1(SB)
MOVD $1741, R12
B callbackasm1(SB)
MOVD $1742, R12
B callbackasm1(SB)
MOVD $1743, R12
B callbackasm1(SB)
MOVD $1744, R12
B callbackasm1(SB)
MOVD $1745, R12
B callbackasm1(SB)
MOVD $1746, R12
B callbackasm1(SB)
MOVD $1747, R12
B callbackasm1(SB)
MOVD $1748, R12
B callbackasm1(SB)
MOVD $1749, R12
B callbackasm1(SB)
MOVD $1750, R12
B callbackasm1(SB)
MOVD $1751, R12
B callbackasm1(SB)
MOVD $1752, R12
B callbackasm1(SB)
MOVD $1753, R12
B callbackasm1(SB)
MOVD $1754, R12
B callbackasm1(SB)
MOVD $1755, R12
B callbackasm1(SB)
MOVD $1756, R12
B callbackasm1(SB)
MOVD $1757, R12
B callbackasm1(SB)
MOVD $1758, R12
B callbackasm1(SB)
MOVD $1759, R12
B callbackasm1(SB)
MOVD $1760, R12
B callbackasm1(SB)
MOVD $1761, R12
B callbackasm1(SB)
MOVD $1762, R12
B callbackasm1(SB)
MOVD $1763, R12
B callbackasm1(SB)
MOVD $1764, R12
B callbackasm1(SB)
MOVD $1765, R12
B callbackasm1(SB)
MOVD $1766, R12
B callbackasm1(SB)
MOVD $1767, R12
B callbackasm1(SB)
MOVD $1768, R12
B callbackasm1(SB)
MOVD $1769, R12
B callbackasm1(SB)
MOVD $1770, R12
B callbackasm1(SB)
MOVD $1771, R12
B callbackasm1(SB)
MOVD $1772, R12
B callbackasm1(SB)
MOVD $1773, R12
B callbackasm1(SB)
MOVD $1774, R12
B callbackasm1(SB)
MOVD $1775, R12
B callbackasm1(SB)
MOVD $1776, R12
B callbackasm1(SB)
MOVD $1777, R12
B callbackasm1(SB)
MOVD $1778, R12
B callbackasm1(SB)
MOVD $1779, R12
B callbackasm1(SB)
MOVD $1780, R12
B callbackasm1(SB)
MOVD $1781, R12
B callbackasm1(SB)
MOVD $1782, R12
B callbackasm1(SB)
MOVD $1783, R12
B callbackasm1(SB)
MOVD $1784, R12
B callbackasm1(SB)
MOVD $1785, R12
B callbackasm1(SB)
MOVD $1786, R12
B callbackasm1(SB)
MOVD $1787, R12
B callbackasm1(SB)
MOVD $1788, R12
B callbackasm1(SB)
MOVD $1789, R12
B callbackasm1(SB)
MOVD $1790, R12
B callbackasm1(SB)
MOVD $1791, R12
B callbackasm1(SB)
MOVD $1792, R12
B callbackasm1(SB)
MOVD $1793, R12
B callbackasm1(SB)
MOVD $1794, R12
B callbackasm1(SB)
MOVD $1795, R12
B callbackasm1(SB)
MOVD $1796, R12
B callbackasm1(SB)
MOVD $1797, R12
B callbackasm1(SB)
MOVD $1798, R12
B callbackasm1(SB)
MOVD $1799, R12
B callbackasm1(SB)
MOVD $1800, R12
B callbackasm1(SB)
MOVD $1801, R12
B callbackasm1(SB)
MOVD $1802, R12
B callbackasm1(SB)
MOVD $1803, R12
B callbackasm1(SB)
MOVD $1804, R12
B callbackasm1(SB)
MOVD $1805, R12
B callbackasm1(SB)
MOVD $1806, R12
B callbackasm1(SB)
MOVD $1807, R12
B callbackasm1(SB)
MOVD $1808, R12
B callbackasm1(SB)
MOVD $1809, R12
B callbackasm1(SB)
MOVD $1810, R12
B callbackasm1(SB)
MOVD $1811, R12
B callbackasm1(SB)
MOVD $1812, R12
B callbackasm1(SB)
MOVD $1813, R12
B callbackasm1(SB)
MOVD $1814, R12
B callbackasm1(SB)
MOVD $1815, R12
B callbackasm1(SB)
MOVD $1816, R12
B callbackasm1(SB)
MOVD $1817, R12
B callbackasm1(SB)
MOVD $1818, R12
B callbackasm1(SB)
MOVD $1819, R12
B callbackasm1(SB)
MOVD $1820, R12
B callbackasm1(SB)
MOVD $1821, R12
B callbackasm1(SB)
MOVD $1822, R12
B callbackasm1(SB)
MOVD $1823, R12
B callbackasm1(SB)
MOVD $1824, R12
B callbackasm1(SB)
MOVD $1825, R12
B callbackasm1(SB)
MOVD $1826, R12
B callbackasm1(SB)
MOVD $1827, R12
B callbackasm1(SB)
MOVD $1828, R12
B callbackasm1(SB)
MOVD $1829, R12
B callbackasm1(SB)
MOVD $1830, R12
B callbackasm1(SB)
MOVD $1831, R12
B callbackasm1(SB)
MOVD $1832, R12
B callbackasm1(SB)
MOVD $1833, R12
B callbackasm1(SB)
MOVD $1834, R12
B callbackasm1(SB)
MOVD $1835, R12
B callbackasm1(SB)
MOVD $1836, R12
B callbackasm1(SB)
MOVD $1837, R12
B callbackasm1(SB)
MOVD $1838, R12
B callbackasm1(SB)
MOVD $1839, R12
B callbackasm1(SB)
MOVD $1840, R12
B callbackasm1(SB)
MOVD $1841, R12
B callbackasm1(SB)
MOVD $1842, R12
B callbackasm1(SB)
MOVD $1843, R12
B callbackasm1(SB)
MOVD $1844, R12
B callbackasm1(SB)
MOVD $1845, R12
B callbackasm1(SB)
MOVD $1846, R12
B callbackasm1(SB)
MOVD $1847, R12
B callbackasm1(SB)
MOVD $1848, R12
B callbackasm1(SB)
MOVD $1849, R12
B callbackasm1(SB)
MOVD $1850, R12
B callbackasm1(SB)
MOVD $1851, R12
B callbackasm1(SB)
MOVD $1852, R12
B callbackasm1(SB)
MOVD $1853, R12
B callbackasm1(SB)
MOVD $1854, R12
B callbackasm1(SB)
MOVD $1855, R12
B callbackasm1(SB)
MOVD $1856, R12
B callbackasm1(SB)
MOVD $1857, R12
B callbackasm1(SB)
MOVD $1858, R12
B callbackasm1(SB)
MOVD $1859, R12
B callbackasm1(SB)
MOVD $1860, R12
B callbackasm1(SB)
MOVD $1861, R12
B callbackasm1(SB)
MOVD $1862, R12
B callbackasm1(SB)
MOVD $1863, R12
B callbackasm1(SB)
MOVD $1864, R12
B callbackasm1(SB)
MOVD $1865, R12
B callbackasm1(SB)
MOVD $1866, R12
B callbackasm1(SB)
MOVD $1867, R12
B callbackasm1(SB)
MOVD $1868, R12
B callbackasm1(SB)
MOVD $1869, R12
B callbackasm1(SB)
MOVD $1870, R12
B callbackasm1(SB)
MOVD $1871, R12
B callbackasm1(SB)
MOVD $1872, R12
B callbackasm1(SB)
MOVD $1873, R12
B callbackasm1(SB)
MOVD $1874, R12
B callbackasm1(SB)
MOVD $1875, R12
B callbackasm1(SB)
MOVD $1876, R12
B callbackasm1(SB)
MOVD $1877, R12
B callbackasm1(SB)
MOVD $1878, R12
B callbackasm1(SB)
MOVD $1879, R12
B callbackasm1(SB)
MOVD $1880, R12
B callbackasm1(SB)
MOVD $1881, R12
B callbackasm1(SB)
MOVD $1882, R12
B callbackasm1(SB)
MOVD $1883, R12
B callbackasm1(SB)
MOVD $1884, R12
B callbackasm1(SB)
MOVD $1885, R12
B callbackasm1(SB)
MOVD $1886, R12
B callbackasm1(SB)
MOVD $1887, R12
B callbackasm1(SB)
MOVD $1888, R12
B callbackasm1(SB)
MOVD $1889, R12
B callbackasm1(SB)
MOVD $1890, R12
B callbackasm1(SB)
MOVD $1891, R12
B callbackasm1(SB)
MOVD $1892, R12
B callbackasm1(SB)
MOVD $1893, R12
B callbackasm1(SB)
MOVD $1894, R12
B callbackasm1(SB)
MOVD $1895, R12
B callbackasm1(SB)
MOVD $1896, R12
B callbackasm1(SB)
MOVD $1897, R12
B callbackasm1(SB)
MOVD $1898, R12
B callbackasm1(SB)
MOVD $1899, R12
B callbackasm1(SB)
MOVD $1900, R12
B callbackasm1(SB)
MOVD $1901, R12
B callbackasm1(SB)
MOVD $1902, R12
B callbackasm1(SB)
MOVD $1903, R12
B callbackasm1(SB)
MOVD $1904, R12
B callbackasm1(SB)
MOVD $1905, R12
B callbackasm1(SB)
MOVD $1906, R12
B callbackasm1(SB)
MOVD $1907, R12
B callbackasm1(SB)
MOVD $1908, R12
B callbackasm1(SB)
MOVD $1909, R12
B callbackasm1(SB)
MOVD $1910, R12
B callbackasm1(SB)
MOVD $1911, R12
B callbackasm1(SB)
MOVD $1912, R12
B callbackasm1(SB)
MOVD $1913, R12
B callbackasm1(SB)
MOVD $1914, R12
B callbackasm1(SB)
MOVD $1915, R12
B callbackasm1(SB)
MOVD $1916, R12
B callbackasm1(SB)
MOVD $1917, R12
B callbackasm1(SB)
MOVD $1918, R12
B callbackasm1(SB)
MOVD $1919, R12
B callbackasm1(SB)
MOVD $1920, R12
B callbackasm1(SB)
MOVD $1921, R12
B callbackasm1(SB)
MOVD $1922, R12
B callbackasm1(SB)
MOVD $1923, R12
B callbackasm1(SB)
MOVD $1924, R12
B callbackasm1(SB)
MOVD $1925, R12
B callbackasm1(SB)
MOVD $1926, R12
B callbackasm1(SB)
MOVD $1927, R12
B callbackasm1(SB)
MOVD $1928, R12
B callbackasm1(SB)
MOVD $1929, R12
B callbackasm1(SB)
MOVD $1930, R12
B callbackasm1(SB)
MOVD $1931, R12
B callbackasm1(SB)
MOVD $1932, R12
B callbackasm1(SB)
MOVD $1933, R12
B callbackasm1(SB)
MOVD $1934, R12
B callbackasm1(SB)
MOVD $1935, R12
B callbackasm1(SB)
MOVD $1936, R12
B callbackasm1(SB)
MOVD $1937, R12
B callbackasm1(SB)
MOVD $1938, R12
B callbackasm1(SB)
MOVD $1939, R12
B callbackasm1(SB)
MOVD $1940, R12
B callbackasm1(SB)
MOVD $1941, R12
B callbackasm1(SB)
MOVD $1942, R12
B callbackasm1(SB)
MOVD $1943, R12
B callbackasm1(SB)
MOVD $1944, R12
B callbackasm1(SB)
MOVD $1945, R12
B callbackasm1(SB)
MOVD $1946, R12
B callbackasm1(SB)
MOVD $1947, R12
B callbackasm1(SB)
MOVD $1948, R12
B callbackasm1(SB)
MOVD $1949, R12
B callbackasm1(SB)
MOVD $1950, R12
B callbackasm1(SB)
MOVD $1951, R12
B callbackasm1(SB)
MOVD $1952, R12
B callbackasm1(SB)
MOVD $1953, R12
B callbackasm1(SB)
MOVD $1954, R12
B callbackasm1(SB)
MOVD $1955, R12
B callbackasm1(SB)
MOVD $1956, R12
B callbackasm1(SB)
MOVD $1957, R12
B callbackasm1(SB)
MOVD $1958, R12
B callbackasm1(SB)
MOVD $1959, R12
B callbackasm1(SB)
MOVD $1960, R12
B callbackasm1(SB)
MOVD $1961, R12
B callbackasm1(SB)
MOVD $1962, R12
B callbackasm1(SB)
MOVD $1963, R12
B callbackasm1(SB)
MOVD $1964, R12
B callbackasm1(SB)
MOVD $1965, R12
B callbackasm1(SB)
MOVD $1966, R12
B callbackasm1(SB)
MOVD $1967, R12
B callbackasm1(SB)
MOVD $1968, R12
B callbackasm1(SB)
MOVD $1969, R12
B callbackasm1(SB)
MOVD $1970, R12
B callbackasm1(SB)
MOVD $1971, R12
B callbackasm1(SB)
MOVD $1972, R12
B callbackasm1(SB)
MOVD $1973, R12
B callbackasm1(SB)
MOVD $1974, R12
B callbackasm1(SB)
MOVD $1975, R12
B callbackasm1(SB)
MOVD $1976, R12
B callbackasm1(SB)
MOVD $1977, R12
B callbackasm1(SB)
MOVD $1978, R12
B callbackasm1(SB)
MOVD $1979, R12
B callbackasm1(SB)
MOVD $1980, R12
B callbackasm1(SB)
MOVD $1981, R12
B callbackasm1(SB)
MOVD $1982, R12
B callbackasm1(SB)
MOVD $1983, R12
B callbackasm1(SB)
MOVD $1984, R12
B callbackasm1(SB)
MOVD $1985, R12
B callbackasm1(SB)
MOVD $1986, R12
B callbackasm1(SB)
MOVD $1987, R12
B callbackasm1(SB)
MOVD $1988, R12
B callbackasm1(SB)
MOVD $1989, R12
B callbackasm1(SB)
MOVD $1990, R12
B callbackasm1(SB)
MOVD $1991, R12
B callbackasm1(SB)
MOVD $1992, R12
B callbackasm1(SB)
MOVD $1993, R12
B callbackasm1(SB)
MOVD $1994, R12
B callbackasm1(SB)
MOVD $1995, R12
B callbackasm1(SB)
MOVD $1996, R12
B callbackasm1(SB)
MOVD $1997, R12
B callbackasm1(SB)
MOVD $1998, R12
B callbackasm1(SB)
MOVD $1999, R12
B callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_loong64.s 0000664 0000000 0000000 00000233233 15207302613 0023415 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVV and JMP instructions.
// The MOVV instruction loads R12 with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVV $0, R12
JMP callbackasm1(SB)
MOVV $1, R12
JMP callbackasm1(SB)
MOVV $2, R12
JMP callbackasm1(SB)
MOVV $3, R12
JMP callbackasm1(SB)
MOVV $4, R12
JMP callbackasm1(SB)
MOVV $5, R12
JMP callbackasm1(SB)
MOVV $6, R12
JMP callbackasm1(SB)
MOVV $7, R12
JMP callbackasm1(SB)
MOVV $8, R12
JMP callbackasm1(SB)
MOVV $9, R12
JMP callbackasm1(SB)
MOVV $10, R12
JMP callbackasm1(SB)
MOVV $11, R12
JMP callbackasm1(SB)
MOVV $12, R12
JMP callbackasm1(SB)
MOVV $13, R12
JMP callbackasm1(SB)
MOVV $14, R12
JMP callbackasm1(SB)
MOVV $15, R12
JMP callbackasm1(SB)
MOVV $16, R12
JMP callbackasm1(SB)
MOVV $17, R12
JMP callbackasm1(SB)
MOVV $18, R12
JMP callbackasm1(SB)
MOVV $19, R12
JMP callbackasm1(SB)
MOVV $20, R12
JMP callbackasm1(SB)
MOVV $21, R12
JMP callbackasm1(SB)
MOVV $22, R12
JMP callbackasm1(SB)
MOVV $23, R12
JMP callbackasm1(SB)
MOVV $24, R12
JMP callbackasm1(SB)
MOVV $25, R12
JMP callbackasm1(SB)
MOVV $26, R12
JMP callbackasm1(SB)
MOVV $27, R12
JMP callbackasm1(SB)
MOVV $28, R12
JMP callbackasm1(SB)
MOVV $29, R12
JMP callbackasm1(SB)
MOVV $30, R12
JMP callbackasm1(SB)
MOVV $31, R12
JMP callbackasm1(SB)
MOVV $32, R12
JMP callbackasm1(SB)
MOVV $33, R12
JMP callbackasm1(SB)
MOVV $34, R12
JMP callbackasm1(SB)
MOVV $35, R12
JMP callbackasm1(SB)
MOVV $36, R12
JMP callbackasm1(SB)
MOVV $37, R12
JMP callbackasm1(SB)
MOVV $38, R12
JMP callbackasm1(SB)
MOVV $39, R12
JMP callbackasm1(SB)
MOVV $40, R12
JMP callbackasm1(SB)
MOVV $41, R12
JMP callbackasm1(SB)
MOVV $42, R12
JMP callbackasm1(SB)
MOVV $43, R12
JMP callbackasm1(SB)
MOVV $44, R12
JMP callbackasm1(SB)
MOVV $45, R12
JMP callbackasm1(SB)
MOVV $46, R12
JMP callbackasm1(SB)
MOVV $47, R12
JMP callbackasm1(SB)
MOVV $48, R12
JMP callbackasm1(SB)
MOVV $49, R12
JMP callbackasm1(SB)
MOVV $50, R12
JMP callbackasm1(SB)
MOVV $51, R12
JMP callbackasm1(SB)
MOVV $52, R12
JMP callbackasm1(SB)
MOVV $53, R12
JMP callbackasm1(SB)
MOVV $54, R12
JMP callbackasm1(SB)
MOVV $55, R12
JMP callbackasm1(SB)
MOVV $56, R12
JMP callbackasm1(SB)
MOVV $57, R12
JMP callbackasm1(SB)
MOVV $58, R12
JMP callbackasm1(SB)
MOVV $59, R12
JMP callbackasm1(SB)
MOVV $60, R12
JMP callbackasm1(SB)
MOVV $61, R12
JMP callbackasm1(SB)
MOVV $62, R12
JMP callbackasm1(SB)
MOVV $63, R12
JMP callbackasm1(SB)
MOVV $64, R12
JMP callbackasm1(SB)
MOVV $65, R12
JMP callbackasm1(SB)
MOVV $66, R12
JMP callbackasm1(SB)
MOVV $67, R12
JMP callbackasm1(SB)
MOVV $68, R12
JMP callbackasm1(SB)
MOVV $69, R12
JMP callbackasm1(SB)
MOVV $70, R12
JMP callbackasm1(SB)
MOVV $71, R12
JMP callbackasm1(SB)
MOVV $72, R12
JMP callbackasm1(SB)
MOVV $73, R12
JMP callbackasm1(SB)
MOVV $74, R12
JMP callbackasm1(SB)
MOVV $75, R12
JMP callbackasm1(SB)
MOVV $76, R12
JMP callbackasm1(SB)
MOVV $77, R12
JMP callbackasm1(SB)
MOVV $78, R12
JMP callbackasm1(SB)
MOVV $79, R12
JMP callbackasm1(SB)
MOVV $80, R12
JMP callbackasm1(SB)
MOVV $81, R12
JMP callbackasm1(SB)
MOVV $82, R12
JMP callbackasm1(SB)
MOVV $83, R12
JMP callbackasm1(SB)
MOVV $84, R12
JMP callbackasm1(SB)
MOVV $85, R12
JMP callbackasm1(SB)
MOVV $86, R12
JMP callbackasm1(SB)
MOVV $87, R12
JMP callbackasm1(SB)
MOVV $88, R12
JMP callbackasm1(SB)
MOVV $89, R12
JMP callbackasm1(SB)
MOVV $90, R12
JMP callbackasm1(SB)
MOVV $91, R12
JMP callbackasm1(SB)
MOVV $92, R12
JMP callbackasm1(SB)
MOVV $93, R12
JMP callbackasm1(SB)
MOVV $94, R12
JMP callbackasm1(SB)
MOVV $95, R12
JMP callbackasm1(SB)
MOVV $96, R12
JMP callbackasm1(SB)
MOVV $97, R12
JMP callbackasm1(SB)
MOVV $98, R12
JMP callbackasm1(SB)
MOVV $99, R12
JMP callbackasm1(SB)
MOVV $100, R12
JMP callbackasm1(SB)
MOVV $101, R12
JMP callbackasm1(SB)
MOVV $102, R12
JMP callbackasm1(SB)
MOVV $103, R12
JMP callbackasm1(SB)
MOVV $104, R12
JMP callbackasm1(SB)
MOVV $105, R12
JMP callbackasm1(SB)
MOVV $106, R12
JMP callbackasm1(SB)
MOVV $107, R12
JMP callbackasm1(SB)
MOVV $108, R12
JMP callbackasm1(SB)
MOVV $109, R12
JMP callbackasm1(SB)
MOVV $110, R12
JMP callbackasm1(SB)
MOVV $111, R12
JMP callbackasm1(SB)
MOVV $112, R12
JMP callbackasm1(SB)
MOVV $113, R12
JMP callbackasm1(SB)
MOVV $114, R12
JMP callbackasm1(SB)
MOVV $115, R12
JMP callbackasm1(SB)
MOVV $116, R12
JMP callbackasm1(SB)
MOVV $117, R12
JMP callbackasm1(SB)
MOVV $118, R12
JMP callbackasm1(SB)
MOVV $119, R12
JMP callbackasm1(SB)
MOVV $120, R12
JMP callbackasm1(SB)
MOVV $121, R12
JMP callbackasm1(SB)
MOVV $122, R12
JMP callbackasm1(SB)
MOVV $123, R12
JMP callbackasm1(SB)
MOVV $124, R12
JMP callbackasm1(SB)
MOVV $125, R12
JMP callbackasm1(SB)
MOVV $126, R12
JMP callbackasm1(SB)
MOVV $127, R12
JMP callbackasm1(SB)
MOVV $128, R12
JMP callbackasm1(SB)
MOVV $129, R12
JMP callbackasm1(SB)
MOVV $130, R12
JMP callbackasm1(SB)
MOVV $131, R12
JMP callbackasm1(SB)
MOVV $132, R12
JMP callbackasm1(SB)
MOVV $133, R12
JMP callbackasm1(SB)
MOVV $134, R12
JMP callbackasm1(SB)
MOVV $135, R12
JMP callbackasm1(SB)
MOVV $136, R12
JMP callbackasm1(SB)
MOVV $137, R12
JMP callbackasm1(SB)
MOVV $138, R12
JMP callbackasm1(SB)
MOVV $139, R12
JMP callbackasm1(SB)
MOVV $140, R12
JMP callbackasm1(SB)
MOVV $141, R12
JMP callbackasm1(SB)
MOVV $142, R12
JMP callbackasm1(SB)
MOVV $143, R12
JMP callbackasm1(SB)
MOVV $144, R12
JMP callbackasm1(SB)
MOVV $145, R12
JMP callbackasm1(SB)
MOVV $146, R12
JMP callbackasm1(SB)
MOVV $147, R12
JMP callbackasm1(SB)
MOVV $148, R12
JMP callbackasm1(SB)
MOVV $149, R12
JMP callbackasm1(SB)
MOVV $150, R12
JMP callbackasm1(SB)
MOVV $151, R12
JMP callbackasm1(SB)
MOVV $152, R12
JMP callbackasm1(SB)
MOVV $153, R12
JMP callbackasm1(SB)
MOVV $154, R12
JMP callbackasm1(SB)
MOVV $155, R12
JMP callbackasm1(SB)
MOVV $156, R12
JMP callbackasm1(SB)
MOVV $157, R12
JMP callbackasm1(SB)
MOVV $158, R12
JMP callbackasm1(SB)
MOVV $159, R12
JMP callbackasm1(SB)
MOVV $160, R12
JMP callbackasm1(SB)
MOVV $161, R12
JMP callbackasm1(SB)
MOVV $162, R12
JMP callbackasm1(SB)
MOVV $163, R12
JMP callbackasm1(SB)
MOVV $164, R12
JMP callbackasm1(SB)
MOVV $165, R12
JMP callbackasm1(SB)
MOVV $166, R12
JMP callbackasm1(SB)
MOVV $167, R12
JMP callbackasm1(SB)
MOVV $168, R12
JMP callbackasm1(SB)
MOVV $169, R12
JMP callbackasm1(SB)
MOVV $170, R12
JMP callbackasm1(SB)
MOVV $171, R12
JMP callbackasm1(SB)
MOVV $172, R12
JMP callbackasm1(SB)
MOVV $173, R12
JMP callbackasm1(SB)
MOVV $174, R12
JMP callbackasm1(SB)
MOVV $175, R12
JMP callbackasm1(SB)
MOVV $176, R12
JMP callbackasm1(SB)
MOVV $177, R12
JMP callbackasm1(SB)
MOVV $178, R12
JMP callbackasm1(SB)
MOVV $179, R12
JMP callbackasm1(SB)
MOVV $180, R12
JMP callbackasm1(SB)
MOVV $181, R12
JMP callbackasm1(SB)
MOVV $182, R12
JMP callbackasm1(SB)
MOVV $183, R12
JMP callbackasm1(SB)
MOVV $184, R12
JMP callbackasm1(SB)
MOVV $185, R12
JMP callbackasm1(SB)
MOVV $186, R12
JMP callbackasm1(SB)
MOVV $187, R12
JMP callbackasm1(SB)
MOVV $188, R12
JMP callbackasm1(SB)
MOVV $189, R12
JMP callbackasm1(SB)
MOVV $190, R12
JMP callbackasm1(SB)
MOVV $191, R12
JMP callbackasm1(SB)
MOVV $192, R12
JMP callbackasm1(SB)
MOVV $193, R12
JMP callbackasm1(SB)
MOVV $194, R12
JMP callbackasm1(SB)
MOVV $195, R12
JMP callbackasm1(SB)
MOVV $196, R12
JMP callbackasm1(SB)
MOVV $197, R12
JMP callbackasm1(SB)
MOVV $198, R12
JMP callbackasm1(SB)
MOVV $199, R12
JMP callbackasm1(SB)
MOVV $200, R12
JMP callbackasm1(SB)
MOVV $201, R12
JMP callbackasm1(SB)
MOVV $202, R12
JMP callbackasm1(SB)
MOVV $203, R12
JMP callbackasm1(SB)
MOVV $204, R12
JMP callbackasm1(SB)
MOVV $205, R12
JMP callbackasm1(SB)
MOVV $206, R12
JMP callbackasm1(SB)
MOVV $207, R12
JMP callbackasm1(SB)
MOVV $208, R12
JMP callbackasm1(SB)
MOVV $209, R12
JMP callbackasm1(SB)
MOVV $210, R12
JMP callbackasm1(SB)
MOVV $211, R12
JMP callbackasm1(SB)
MOVV $212, R12
JMP callbackasm1(SB)
MOVV $213, R12
JMP callbackasm1(SB)
MOVV $214, R12
JMP callbackasm1(SB)
MOVV $215, R12
JMP callbackasm1(SB)
MOVV $216, R12
JMP callbackasm1(SB)
MOVV $217, R12
JMP callbackasm1(SB)
MOVV $218, R12
JMP callbackasm1(SB)
MOVV $219, R12
JMP callbackasm1(SB)
MOVV $220, R12
JMP callbackasm1(SB)
MOVV $221, R12
JMP callbackasm1(SB)
MOVV $222, R12
JMP callbackasm1(SB)
MOVV $223, R12
JMP callbackasm1(SB)
MOVV $224, R12
JMP callbackasm1(SB)
MOVV $225, R12
JMP callbackasm1(SB)
MOVV $226, R12
JMP callbackasm1(SB)
MOVV $227, R12
JMP callbackasm1(SB)
MOVV $228, R12
JMP callbackasm1(SB)
MOVV $229, R12
JMP callbackasm1(SB)
MOVV $230, R12
JMP callbackasm1(SB)
MOVV $231, R12
JMP callbackasm1(SB)
MOVV $232, R12
JMP callbackasm1(SB)
MOVV $233, R12
JMP callbackasm1(SB)
MOVV $234, R12
JMP callbackasm1(SB)
MOVV $235, R12
JMP callbackasm1(SB)
MOVV $236, R12
JMP callbackasm1(SB)
MOVV $237, R12
JMP callbackasm1(SB)
MOVV $238, R12
JMP callbackasm1(SB)
MOVV $239, R12
JMP callbackasm1(SB)
MOVV $240, R12
JMP callbackasm1(SB)
MOVV $241, R12
JMP callbackasm1(SB)
MOVV $242, R12
JMP callbackasm1(SB)
MOVV $243, R12
JMP callbackasm1(SB)
MOVV $244, R12
JMP callbackasm1(SB)
MOVV $245, R12
JMP callbackasm1(SB)
MOVV $246, R12
JMP callbackasm1(SB)
MOVV $247, R12
JMP callbackasm1(SB)
MOVV $248, R12
JMP callbackasm1(SB)
MOVV $249, R12
JMP callbackasm1(SB)
MOVV $250, R12
JMP callbackasm1(SB)
MOVV $251, R12
JMP callbackasm1(SB)
MOVV $252, R12
JMP callbackasm1(SB)
MOVV $253, R12
JMP callbackasm1(SB)
MOVV $254, R12
JMP callbackasm1(SB)
MOVV $255, R12
JMP callbackasm1(SB)
MOVV $256, R12
JMP callbackasm1(SB)
MOVV $257, R12
JMP callbackasm1(SB)
MOVV $258, R12
JMP callbackasm1(SB)
MOVV $259, R12
JMP callbackasm1(SB)
MOVV $260, R12
JMP callbackasm1(SB)
MOVV $261, R12
JMP callbackasm1(SB)
MOVV $262, R12
JMP callbackasm1(SB)
MOVV $263, R12
JMP callbackasm1(SB)
MOVV $264, R12
JMP callbackasm1(SB)
MOVV $265, R12
JMP callbackasm1(SB)
MOVV $266, R12
JMP callbackasm1(SB)
MOVV $267, R12
JMP callbackasm1(SB)
MOVV $268, R12
JMP callbackasm1(SB)
MOVV $269, R12
JMP callbackasm1(SB)
MOVV $270, R12
JMP callbackasm1(SB)
MOVV $271, R12
JMP callbackasm1(SB)
MOVV $272, R12
JMP callbackasm1(SB)
MOVV $273, R12
JMP callbackasm1(SB)
MOVV $274, R12
JMP callbackasm1(SB)
MOVV $275, R12
JMP callbackasm1(SB)
MOVV $276, R12
JMP callbackasm1(SB)
MOVV $277, R12
JMP callbackasm1(SB)
MOVV $278, R12
JMP callbackasm1(SB)
MOVV $279, R12
JMP callbackasm1(SB)
MOVV $280, R12
JMP callbackasm1(SB)
MOVV $281, R12
JMP callbackasm1(SB)
MOVV $282, R12
JMP callbackasm1(SB)
MOVV $283, R12
JMP callbackasm1(SB)
MOVV $284, R12
JMP callbackasm1(SB)
MOVV $285, R12
JMP callbackasm1(SB)
MOVV $286, R12
JMP callbackasm1(SB)
MOVV $287, R12
JMP callbackasm1(SB)
MOVV $288, R12
JMP callbackasm1(SB)
MOVV $289, R12
JMP callbackasm1(SB)
MOVV $290, R12
JMP callbackasm1(SB)
MOVV $291, R12
JMP callbackasm1(SB)
MOVV $292, R12
JMP callbackasm1(SB)
MOVV $293, R12
JMP callbackasm1(SB)
MOVV $294, R12
JMP callbackasm1(SB)
MOVV $295, R12
JMP callbackasm1(SB)
MOVV $296, R12
JMP callbackasm1(SB)
MOVV $297, R12
JMP callbackasm1(SB)
MOVV $298, R12
JMP callbackasm1(SB)
MOVV $299, R12
JMP callbackasm1(SB)
MOVV $300, R12
JMP callbackasm1(SB)
MOVV $301, R12
JMP callbackasm1(SB)
MOVV $302, R12
JMP callbackasm1(SB)
MOVV $303, R12
JMP callbackasm1(SB)
MOVV $304, R12
JMP callbackasm1(SB)
MOVV $305, R12
JMP callbackasm1(SB)
MOVV $306, R12
JMP callbackasm1(SB)
MOVV $307, R12
JMP callbackasm1(SB)
MOVV $308, R12
JMP callbackasm1(SB)
MOVV $309, R12
JMP callbackasm1(SB)
MOVV $310, R12
JMP callbackasm1(SB)
MOVV $311, R12
JMP callbackasm1(SB)
MOVV $312, R12
JMP callbackasm1(SB)
MOVV $313, R12
JMP callbackasm1(SB)
MOVV $314, R12
JMP callbackasm1(SB)
MOVV $315, R12
JMP callbackasm1(SB)
MOVV $316, R12
JMP callbackasm1(SB)
MOVV $317, R12
JMP callbackasm1(SB)
MOVV $318, R12
JMP callbackasm1(SB)
MOVV $319, R12
JMP callbackasm1(SB)
MOVV $320, R12
JMP callbackasm1(SB)
MOVV $321, R12
JMP callbackasm1(SB)
MOVV $322, R12
JMP callbackasm1(SB)
MOVV $323, R12
JMP callbackasm1(SB)
MOVV $324, R12
JMP callbackasm1(SB)
MOVV $325, R12
JMP callbackasm1(SB)
MOVV $326, R12
JMP callbackasm1(SB)
MOVV $327, R12
JMP callbackasm1(SB)
MOVV $328, R12
JMP callbackasm1(SB)
MOVV $329, R12
JMP callbackasm1(SB)
MOVV $330, R12
JMP callbackasm1(SB)
MOVV $331, R12
JMP callbackasm1(SB)
MOVV $332, R12
JMP callbackasm1(SB)
MOVV $333, R12
JMP callbackasm1(SB)
MOVV $334, R12
JMP callbackasm1(SB)
MOVV $335, R12
JMP callbackasm1(SB)
MOVV $336, R12
JMP callbackasm1(SB)
MOVV $337, R12
JMP callbackasm1(SB)
MOVV $338, R12
JMP callbackasm1(SB)
MOVV $339, R12
JMP callbackasm1(SB)
MOVV $340, R12
JMP callbackasm1(SB)
MOVV $341, R12
JMP callbackasm1(SB)
MOVV $342, R12
JMP callbackasm1(SB)
MOVV $343, R12
JMP callbackasm1(SB)
MOVV $344, R12
JMP callbackasm1(SB)
MOVV $345, R12
JMP callbackasm1(SB)
MOVV $346, R12
JMP callbackasm1(SB)
MOVV $347, R12
JMP callbackasm1(SB)
MOVV $348, R12
JMP callbackasm1(SB)
MOVV $349, R12
JMP callbackasm1(SB)
MOVV $350, R12
JMP callbackasm1(SB)
MOVV $351, R12
JMP callbackasm1(SB)
MOVV $352, R12
JMP callbackasm1(SB)
MOVV $353, R12
JMP callbackasm1(SB)
MOVV $354, R12
JMP callbackasm1(SB)
MOVV $355, R12
JMP callbackasm1(SB)
MOVV $356, R12
JMP callbackasm1(SB)
MOVV $357, R12
JMP callbackasm1(SB)
MOVV $358, R12
JMP callbackasm1(SB)
MOVV $359, R12
JMP callbackasm1(SB)
MOVV $360, R12
JMP callbackasm1(SB)
MOVV $361, R12
JMP callbackasm1(SB)
MOVV $362, R12
JMP callbackasm1(SB)
MOVV $363, R12
JMP callbackasm1(SB)
MOVV $364, R12
JMP callbackasm1(SB)
MOVV $365, R12
JMP callbackasm1(SB)
MOVV $366, R12
JMP callbackasm1(SB)
MOVV $367, R12
JMP callbackasm1(SB)
MOVV $368, R12
JMP callbackasm1(SB)
MOVV $369, R12
JMP callbackasm1(SB)
MOVV $370, R12
JMP callbackasm1(SB)
MOVV $371, R12
JMP callbackasm1(SB)
MOVV $372, R12
JMP callbackasm1(SB)
MOVV $373, R12
JMP callbackasm1(SB)
MOVV $374, R12
JMP callbackasm1(SB)
MOVV $375, R12
JMP callbackasm1(SB)
MOVV $376, R12
JMP callbackasm1(SB)
MOVV $377, R12
JMP callbackasm1(SB)
MOVV $378, R12
JMP callbackasm1(SB)
MOVV $379, R12
JMP callbackasm1(SB)
MOVV $380, R12
JMP callbackasm1(SB)
MOVV $381, R12
JMP callbackasm1(SB)
MOVV $382, R12
JMP callbackasm1(SB)
MOVV $383, R12
JMP callbackasm1(SB)
MOVV $384, R12
JMP callbackasm1(SB)
MOVV $385, R12
JMP callbackasm1(SB)
MOVV $386, R12
JMP callbackasm1(SB)
MOVV $387, R12
JMP callbackasm1(SB)
MOVV $388, R12
JMP callbackasm1(SB)
MOVV $389, R12
JMP callbackasm1(SB)
MOVV $390, R12
JMP callbackasm1(SB)
MOVV $391, R12
JMP callbackasm1(SB)
MOVV $392, R12
JMP callbackasm1(SB)
MOVV $393, R12
JMP callbackasm1(SB)
MOVV $394, R12
JMP callbackasm1(SB)
MOVV $395, R12
JMP callbackasm1(SB)
MOVV $396, R12
JMP callbackasm1(SB)
MOVV $397, R12
JMP callbackasm1(SB)
MOVV $398, R12
JMP callbackasm1(SB)
MOVV $399, R12
JMP callbackasm1(SB)
MOVV $400, R12
JMP callbackasm1(SB)
MOVV $401, R12
JMP callbackasm1(SB)
MOVV $402, R12
JMP callbackasm1(SB)
MOVV $403, R12
JMP callbackasm1(SB)
MOVV $404, R12
JMP callbackasm1(SB)
MOVV $405, R12
JMP callbackasm1(SB)
MOVV $406, R12
JMP callbackasm1(SB)
MOVV $407, R12
JMP callbackasm1(SB)
MOVV $408, R12
JMP callbackasm1(SB)
MOVV $409, R12
JMP callbackasm1(SB)
MOVV $410, R12
JMP callbackasm1(SB)
MOVV $411, R12
JMP callbackasm1(SB)
MOVV $412, R12
JMP callbackasm1(SB)
MOVV $413, R12
JMP callbackasm1(SB)
MOVV $414, R12
JMP callbackasm1(SB)
MOVV $415, R12
JMP callbackasm1(SB)
MOVV $416, R12
JMP callbackasm1(SB)
MOVV $417, R12
JMP callbackasm1(SB)
MOVV $418, R12
JMP callbackasm1(SB)
MOVV $419, R12
JMP callbackasm1(SB)
MOVV $420, R12
JMP callbackasm1(SB)
MOVV $421, R12
JMP callbackasm1(SB)
MOVV $422, R12
JMP callbackasm1(SB)
MOVV $423, R12
JMP callbackasm1(SB)
MOVV $424, R12
JMP callbackasm1(SB)
MOVV $425, R12
JMP callbackasm1(SB)
MOVV $426, R12
JMP callbackasm1(SB)
MOVV $427, R12
JMP callbackasm1(SB)
MOVV $428, R12
JMP callbackasm1(SB)
MOVV $429, R12
JMP callbackasm1(SB)
MOVV $430, R12
JMP callbackasm1(SB)
MOVV $431, R12
JMP callbackasm1(SB)
MOVV $432, R12
JMP callbackasm1(SB)
MOVV $433, R12
JMP callbackasm1(SB)
MOVV $434, R12
JMP callbackasm1(SB)
MOVV $435, R12
JMP callbackasm1(SB)
MOVV $436, R12
JMP callbackasm1(SB)
MOVV $437, R12
JMP callbackasm1(SB)
MOVV $438, R12
JMP callbackasm1(SB)
MOVV $439, R12
JMP callbackasm1(SB)
MOVV $440, R12
JMP callbackasm1(SB)
MOVV $441, R12
JMP callbackasm1(SB)
MOVV $442, R12
JMP callbackasm1(SB)
MOVV $443, R12
JMP callbackasm1(SB)
MOVV $444, R12
JMP callbackasm1(SB)
MOVV $445, R12
JMP callbackasm1(SB)
MOVV $446, R12
JMP callbackasm1(SB)
MOVV $447, R12
JMP callbackasm1(SB)
MOVV $448, R12
JMP callbackasm1(SB)
MOVV $449, R12
JMP callbackasm1(SB)
MOVV $450, R12
JMP callbackasm1(SB)
MOVV $451, R12
JMP callbackasm1(SB)
MOVV $452, R12
JMP callbackasm1(SB)
MOVV $453, R12
JMP callbackasm1(SB)
MOVV $454, R12
JMP callbackasm1(SB)
MOVV $455, R12
JMP callbackasm1(SB)
MOVV $456, R12
JMP callbackasm1(SB)
MOVV $457, R12
JMP callbackasm1(SB)
MOVV $458, R12
JMP callbackasm1(SB)
MOVV $459, R12
JMP callbackasm1(SB)
MOVV $460, R12
JMP callbackasm1(SB)
MOVV $461, R12
JMP callbackasm1(SB)
MOVV $462, R12
JMP callbackasm1(SB)
MOVV $463, R12
JMP callbackasm1(SB)
MOVV $464, R12
JMP callbackasm1(SB)
MOVV $465, R12
JMP callbackasm1(SB)
MOVV $466, R12
JMP callbackasm1(SB)
MOVV $467, R12
JMP callbackasm1(SB)
MOVV $468, R12
JMP callbackasm1(SB)
MOVV $469, R12
JMP callbackasm1(SB)
MOVV $470, R12
JMP callbackasm1(SB)
MOVV $471, R12
JMP callbackasm1(SB)
MOVV $472, R12
JMP callbackasm1(SB)
MOVV $473, R12
JMP callbackasm1(SB)
MOVV $474, R12
JMP callbackasm1(SB)
MOVV $475, R12
JMP callbackasm1(SB)
MOVV $476, R12
JMP callbackasm1(SB)
MOVV $477, R12
JMP callbackasm1(SB)
MOVV $478, R12
JMP callbackasm1(SB)
MOVV $479, R12
JMP callbackasm1(SB)
MOVV $480, R12
JMP callbackasm1(SB)
MOVV $481, R12
JMP callbackasm1(SB)
MOVV $482, R12
JMP callbackasm1(SB)
MOVV $483, R12
JMP callbackasm1(SB)
MOVV $484, R12
JMP callbackasm1(SB)
MOVV $485, R12
JMP callbackasm1(SB)
MOVV $486, R12
JMP callbackasm1(SB)
MOVV $487, R12
JMP callbackasm1(SB)
MOVV $488, R12
JMP callbackasm1(SB)
MOVV $489, R12
JMP callbackasm1(SB)
MOVV $490, R12
JMP callbackasm1(SB)
MOVV $491, R12
JMP callbackasm1(SB)
MOVV $492, R12
JMP callbackasm1(SB)
MOVV $493, R12
JMP callbackasm1(SB)
MOVV $494, R12
JMP callbackasm1(SB)
MOVV $495, R12
JMP callbackasm1(SB)
MOVV $496, R12
JMP callbackasm1(SB)
MOVV $497, R12
JMP callbackasm1(SB)
MOVV $498, R12
JMP callbackasm1(SB)
MOVV $499, R12
JMP callbackasm1(SB)
MOVV $500, R12
JMP callbackasm1(SB)
MOVV $501, R12
JMP callbackasm1(SB)
MOVV $502, R12
JMP callbackasm1(SB)
MOVV $503, R12
JMP callbackasm1(SB)
MOVV $504, R12
JMP callbackasm1(SB)
MOVV $505, R12
JMP callbackasm1(SB)
MOVV $506, R12
JMP callbackasm1(SB)
MOVV $507, R12
JMP callbackasm1(SB)
MOVV $508, R12
JMP callbackasm1(SB)
MOVV $509, R12
JMP callbackasm1(SB)
MOVV $510, R12
JMP callbackasm1(SB)
MOVV $511, R12
JMP callbackasm1(SB)
MOVV $512, R12
JMP callbackasm1(SB)
MOVV $513, R12
JMP callbackasm1(SB)
MOVV $514, R12
JMP callbackasm1(SB)
MOVV $515, R12
JMP callbackasm1(SB)
MOVV $516, R12
JMP callbackasm1(SB)
MOVV $517, R12
JMP callbackasm1(SB)
MOVV $518, R12
JMP callbackasm1(SB)
MOVV $519, R12
JMP callbackasm1(SB)
MOVV $520, R12
JMP callbackasm1(SB)
MOVV $521, R12
JMP callbackasm1(SB)
MOVV $522, R12
JMP callbackasm1(SB)
MOVV $523, R12
JMP callbackasm1(SB)
MOVV $524, R12
JMP callbackasm1(SB)
MOVV $525, R12
JMP callbackasm1(SB)
MOVV $526, R12
JMP callbackasm1(SB)
MOVV $527, R12
JMP callbackasm1(SB)
MOVV $528, R12
JMP callbackasm1(SB)
MOVV $529, R12
JMP callbackasm1(SB)
MOVV $530, R12
JMP callbackasm1(SB)
MOVV $531, R12
JMP callbackasm1(SB)
MOVV $532, R12
JMP callbackasm1(SB)
MOVV $533, R12
JMP callbackasm1(SB)
MOVV $534, R12
JMP callbackasm1(SB)
MOVV $535, R12
JMP callbackasm1(SB)
MOVV $536, R12
JMP callbackasm1(SB)
MOVV $537, R12
JMP callbackasm1(SB)
MOVV $538, R12
JMP callbackasm1(SB)
MOVV $539, R12
JMP callbackasm1(SB)
MOVV $540, R12
JMP callbackasm1(SB)
MOVV $541, R12
JMP callbackasm1(SB)
MOVV $542, R12
JMP callbackasm1(SB)
MOVV $543, R12
JMP callbackasm1(SB)
MOVV $544, R12
JMP callbackasm1(SB)
MOVV $545, R12
JMP callbackasm1(SB)
MOVV $546, R12
JMP callbackasm1(SB)
MOVV $547, R12
JMP callbackasm1(SB)
MOVV $548, R12
JMP callbackasm1(SB)
MOVV $549, R12
JMP callbackasm1(SB)
MOVV $550, R12
JMP callbackasm1(SB)
MOVV $551, R12
JMP callbackasm1(SB)
MOVV $552, R12
JMP callbackasm1(SB)
MOVV $553, R12
JMP callbackasm1(SB)
MOVV $554, R12
JMP callbackasm1(SB)
MOVV $555, R12
JMP callbackasm1(SB)
MOVV $556, R12
JMP callbackasm1(SB)
MOVV $557, R12
JMP callbackasm1(SB)
MOVV $558, R12
JMP callbackasm1(SB)
MOVV $559, R12
JMP callbackasm1(SB)
MOVV $560, R12
JMP callbackasm1(SB)
MOVV $561, R12
JMP callbackasm1(SB)
MOVV $562, R12
JMP callbackasm1(SB)
MOVV $563, R12
JMP callbackasm1(SB)
MOVV $564, R12
JMP callbackasm1(SB)
MOVV $565, R12
JMP callbackasm1(SB)
MOVV $566, R12
JMP callbackasm1(SB)
MOVV $567, R12
JMP callbackasm1(SB)
MOVV $568, R12
JMP callbackasm1(SB)
MOVV $569, R12
JMP callbackasm1(SB)
MOVV $570, R12
JMP callbackasm1(SB)
MOVV $571, R12
JMP callbackasm1(SB)
MOVV $572, R12
JMP callbackasm1(SB)
MOVV $573, R12
JMP callbackasm1(SB)
MOVV $574, R12
JMP callbackasm1(SB)
MOVV $575, R12
JMP callbackasm1(SB)
MOVV $576, R12
JMP callbackasm1(SB)
MOVV $577, R12
JMP callbackasm1(SB)
MOVV $578, R12
JMP callbackasm1(SB)
MOVV $579, R12
JMP callbackasm1(SB)
MOVV $580, R12
JMP callbackasm1(SB)
MOVV $581, R12
JMP callbackasm1(SB)
MOVV $582, R12
JMP callbackasm1(SB)
MOVV $583, R12
JMP callbackasm1(SB)
MOVV $584, R12
JMP callbackasm1(SB)
MOVV $585, R12
JMP callbackasm1(SB)
MOVV $586, R12
JMP callbackasm1(SB)
MOVV $587, R12
JMP callbackasm1(SB)
MOVV $588, R12
JMP callbackasm1(SB)
MOVV $589, R12
JMP callbackasm1(SB)
MOVV $590, R12
JMP callbackasm1(SB)
MOVV $591, R12
JMP callbackasm1(SB)
MOVV $592, R12
JMP callbackasm1(SB)
MOVV $593, R12
JMP callbackasm1(SB)
MOVV $594, R12
JMP callbackasm1(SB)
MOVV $595, R12
JMP callbackasm1(SB)
MOVV $596, R12
JMP callbackasm1(SB)
MOVV $597, R12
JMP callbackasm1(SB)
MOVV $598, R12
JMP callbackasm1(SB)
MOVV $599, R12
JMP callbackasm1(SB)
MOVV $600, R12
JMP callbackasm1(SB)
MOVV $601, R12
JMP callbackasm1(SB)
MOVV $602, R12
JMP callbackasm1(SB)
MOVV $603, R12
JMP callbackasm1(SB)
MOVV $604, R12
JMP callbackasm1(SB)
MOVV $605, R12
JMP callbackasm1(SB)
MOVV $606, R12
JMP callbackasm1(SB)
MOVV $607, R12
JMP callbackasm1(SB)
MOVV $608, R12
JMP callbackasm1(SB)
MOVV $609, R12
JMP callbackasm1(SB)
MOVV $610, R12
JMP callbackasm1(SB)
MOVV $611, R12
JMP callbackasm1(SB)
MOVV $612, R12
JMP callbackasm1(SB)
MOVV $613, R12
JMP callbackasm1(SB)
MOVV $614, R12
JMP callbackasm1(SB)
MOVV $615, R12
JMP callbackasm1(SB)
MOVV $616, R12
JMP callbackasm1(SB)
MOVV $617, R12
JMP callbackasm1(SB)
MOVV $618, R12
JMP callbackasm1(SB)
MOVV $619, R12
JMP callbackasm1(SB)
MOVV $620, R12
JMP callbackasm1(SB)
MOVV $621, R12
JMP callbackasm1(SB)
MOVV $622, R12
JMP callbackasm1(SB)
MOVV $623, R12
JMP callbackasm1(SB)
MOVV $624, R12
JMP callbackasm1(SB)
MOVV $625, R12
JMP callbackasm1(SB)
MOVV $626, R12
JMP callbackasm1(SB)
MOVV $627, R12
JMP callbackasm1(SB)
MOVV $628, R12
JMP callbackasm1(SB)
MOVV $629, R12
JMP callbackasm1(SB)
MOVV $630, R12
JMP callbackasm1(SB)
MOVV $631, R12
JMP callbackasm1(SB)
MOVV $632, R12
JMP callbackasm1(SB)
MOVV $633, R12
JMP callbackasm1(SB)
MOVV $634, R12
JMP callbackasm1(SB)
MOVV $635, R12
JMP callbackasm1(SB)
MOVV $636, R12
JMP callbackasm1(SB)
MOVV $637, R12
JMP callbackasm1(SB)
MOVV $638, R12
JMP callbackasm1(SB)
MOVV $639, R12
JMP callbackasm1(SB)
MOVV $640, R12
JMP callbackasm1(SB)
MOVV $641, R12
JMP callbackasm1(SB)
MOVV $642, R12
JMP callbackasm1(SB)
MOVV $643, R12
JMP callbackasm1(SB)
MOVV $644, R12
JMP callbackasm1(SB)
MOVV $645, R12
JMP callbackasm1(SB)
MOVV $646, R12
JMP callbackasm1(SB)
MOVV $647, R12
JMP callbackasm1(SB)
MOVV $648, R12
JMP callbackasm1(SB)
MOVV $649, R12
JMP callbackasm1(SB)
MOVV $650, R12
JMP callbackasm1(SB)
MOVV $651, R12
JMP callbackasm1(SB)
MOVV $652, R12
JMP callbackasm1(SB)
MOVV $653, R12
JMP callbackasm1(SB)
MOVV $654, R12
JMP callbackasm1(SB)
MOVV $655, R12
JMP callbackasm1(SB)
MOVV $656, R12
JMP callbackasm1(SB)
MOVV $657, R12
JMP callbackasm1(SB)
MOVV $658, R12
JMP callbackasm1(SB)
MOVV $659, R12
JMP callbackasm1(SB)
MOVV $660, R12
JMP callbackasm1(SB)
MOVV $661, R12
JMP callbackasm1(SB)
MOVV $662, R12
JMP callbackasm1(SB)
MOVV $663, R12
JMP callbackasm1(SB)
MOVV $664, R12
JMP callbackasm1(SB)
MOVV $665, R12
JMP callbackasm1(SB)
MOVV $666, R12
JMP callbackasm1(SB)
MOVV $667, R12
JMP callbackasm1(SB)
MOVV $668, R12
JMP callbackasm1(SB)
MOVV $669, R12
JMP callbackasm1(SB)
MOVV $670, R12
JMP callbackasm1(SB)
MOVV $671, R12
JMP callbackasm1(SB)
MOVV $672, R12
JMP callbackasm1(SB)
MOVV $673, R12
JMP callbackasm1(SB)
MOVV $674, R12
JMP callbackasm1(SB)
MOVV $675, R12
JMP callbackasm1(SB)
MOVV $676, R12
JMP callbackasm1(SB)
MOVV $677, R12
JMP callbackasm1(SB)
MOVV $678, R12
JMP callbackasm1(SB)
MOVV $679, R12
JMP callbackasm1(SB)
MOVV $680, R12
JMP callbackasm1(SB)
MOVV $681, R12
JMP callbackasm1(SB)
MOVV $682, R12
JMP callbackasm1(SB)
MOVV $683, R12
JMP callbackasm1(SB)
MOVV $684, R12
JMP callbackasm1(SB)
MOVV $685, R12
JMP callbackasm1(SB)
MOVV $686, R12
JMP callbackasm1(SB)
MOVV $687, R12
JMP callbackasm1(SB)
MOVV $688, R12
JMP callbackasm1(SB)
MOVV $689, R12
JMP callbackasm1(SB)
MOVV $690, R12
JMP callbackasm1(SB)
MOVV $691, R12
JMP callbackasm1(SB)
MOVV $692, R12
JMP callbackasm1(SB)
MOVV $693, R12
JMP callbackasm1(SB)
MOVV $694, R12
JMP callbackasm1(SB)
MOVV $695, R12
JMP callbackasm1(SB)
MOVV $696, R12
JMP callbackasm1(SB)
MOVV $697, R12
JMP callbackasm1(SB)
MOVV $698, R12
JMP callbackasm1(SB)
MOVV $699, R12
JMP callbackasm1(SB)
MOVV $700, R12
JMP callbackasm1(SB)
MOVV $701, R12
JMP callbackasm1(SB)
MOVV $702, R12
JMP callbackasm1(SB)
MOVV $703, R12
JMP callbackasm1(SB)
MOVV $704, R12
JMP callbackasm1(SB)
MOVV $705, R12
JMP callbackasm1(SB)
MOVV $706, R12
JMP callbackasm1(SB)
MOVV $707, R12
JMP callbackasm1(SB)
MOVV $708, R12
JMP callbackasm1(SB)
MOVV $709, R12
JMP callbackasm1(SB)
MOVV $710, R12
JMP callbackasm1(SB)
MOVV $711, R12
JMP callbackasm1(SB)
MOVV $712, R12
JMP callbackasm1(SB)
MOVV $713, R12
JMP callbackasm1(SB)
MOVV $714, R12
JMP callbackasm1(SB)
MOVV $715, R12
JMP callbackasm1(SB)
MOVV $716, R12
JMP callbackasm1(SB)
MOVV $717, R12
JMP callbackasm1(SB)
MOVV $718, R12
JMP callbackasm1(SB)
MOVV $719, R12
JMP callbackasm1(SB)
MOVV $720, R12
JMP callbackasm1(SB)
MOVV $721, R12
JMP callbackasm1(SB)
MOVV $722, R12
JMP callbackasm1(SB)
MOVV $723, R12
JMP callbackasm1(SB)
MOVV $724, R12
JMP callbackasm1(SB)
MOVV $725, R12
JMP callbackasm1(SB)
MOVV $726, R12
JMP callbackasm1(SB)
MOVV $727, R12
JMP callbackasm1(SB)
MOVV $728, R12
JMP callbackasm1(SB)
MOVV $729, R12
JMP callbackasm1(SB)
MOVV $730, R12
JMP callbackasm1(SB)
MOVV $731, R12
JMP callbackasm1(SB)
MOVV $732, R12
JMP callbackasm1(SB)
MOVV $733, R12
JMP callbackasm1(SB)
MOVV $734, R12
JMP callbackasm1(SB)
MOVV $735, R12
JMP callbackasm1(SB)
MOVV $736, R12
JMP callbackasm1(SB)
MOVV $737, R12
JMP callbackasm1(SB)
MOVV $738, R12
JMP callbackasm1(SB)
MOVV $739, R12
JMP callbackasm1(SB)
MOVV $740, R12
JMP callbackasm1(SB)
MOVV $741, R12
JMP callbackasm1(SB)
MOVV $742, R12
JMP callbackasm1(SB)
MOVV $743, R12
JMP callbackasm1(SB)
MOVV $744, R12
JMP callbackasm1(SB)
MOVV $745, R12
JMP callbackasm1(SB)
MOVV $746, R12
JMP callbackasm1(SB)
MOVV $747, R12
JMP callbackasm1(SB)
MOVV $748, R12
JMP callbackasm1(SB)
MOVV $749, R12
JMP callbackasm1(SB)
MOVV $750, R12
JMP callbackasm1(SB)
MOVV $751, R12
JMP callbackasm1(SB)
MOVV $752, R12
JMP callbackasm1(SB)
MOVV $753, R12
JMP callbackasm1(SB)
MOVV $754, R12
JMP callbackasm1(SB)
MOVV $755, R12
JMP callbackasm1(SB)
MOVV $756, R12
JMP callbackasm1(SB)
MOVV $757, R12
JMP callbackasm1(SB)
MOVV $758, R12
JMP callbackasm1(SB)
MOVV $759, R12
JMP callbackasm1(SB)
MOVV $760, R12
JMP callbackasm1(SB)
MOVV $761, R12
JMP callbackasm1(SB)
MOVV $762, R12
JMP callbackasm1(SB)
MOVV $763, R12
JMP callbackasm1(SB)
MOVV $764, R12
JMP callbackasm1(SB)
MOVV $765, R12
JMP callbackasm1(SB)
MOVV $766, R12
JMP callbackasm1(SB)
MOVV $767, R12
JMP callbackasm1(SB)
MOVV $768, R12
JMP callbackasm1(SB)
MOVV $769, R12
JMP callbackasm1(SB)
MOVV $770, R12
JMP callbackasm1(SB)
MOVV $771, R12
JMP callbackasm1(SB)
MOVV $772, R12
JMP callbackasm1(SB)
MOVV $773, R12
JMP callbackasm1(SB)
MOVV $774, R12
JMP callbackasm1(SB)
MOVV $775, R12
JMP callbackasm1(SB)
MOVV $776, R12
JMP callbackasm1(SB)
MOVV $777, R12
JMP callbackasm1(SB)
MOVV $778, R12
JMP callbackasm1(SB)
MOVV $779, R12
JMP callbackasm1(SB)
MOVV $780, R12
JMP callbackasm1(SB)
MOVV $781, R12
JMP callbackasm1(SB)
MOVV $782, R12
JMP callbackasm1(SB)
MOVV $783, R12
JMP callbackasm1(SB)
MOVV $784, R12
JMP callbackasm1(SB)
MOVV $785, R12
JMP callbackasm1(SB)
MOVV $786, R12
JMP callbackasm1(SB)
MOVV $787, R12
JMP callbackasm1(SB)
MOVV $788, R12
JMP callbackasm1(SB)
MOVV $789, R12
JMP callbackasm1(SB)
MOVV $790, R12
JMP callbackasm1(SB)
MOVV $791, R12
JMP callbackasm1(SB)
MOVV $792, R12
JMP callbackasm1(SB)
MOVV $793, R12
JMP callbackasm1(SB)
MOVV $794, R12
JMP callbackasm1(SB)
MOVV $795, R12
JMP callbackasm1(SB)
MOVV $796, R12
JMP callbackasm1(SB)
MOVV $797, R12
JMP callbackasm1(SB)
MOVV $798, R12
JMP callbackasm1(SB)
MOVV $799, R12
JMP callbackasm1(SB)
MOVV $800, R12
JMP callbackasm1(SB)
MOVV $801, R12
JMP callbackasm1(SB)
MOVV $802, R12
JMP callbackasm1(SB)
MOVV $803, R12
JMP callbackasm1(SB)
MOVV $804, R12
JMP callbackasm1(SB)
MOVV $805, R12
JMP callbackasm1(SB)
MOVV $806, R12
JMP callbackasm1(SB)
MOVV $807, R12
JMP callbackasm1(SB)
MOVV $808, R12
JMP callbackasm1(SB)
MOVV $809, R12
JMP callbackasm1(SB)
MOVV $810, R12
JMP callbackasm1(SB)
MOVV $811, R12
JMP callbackasm1(SB)
MOVV $812, R12
JMP callbackasm1(SB)
MOVV $813, R12
JMP callbackasm1(SB)
MOVV $814, R12
JMP callbackasm1(SB)
MOVV $815, R12
JMP callbackasm1(SB)
MOVV $816, R12
JMP callbackasm1(SB)
MOVV $817, R12
JMP callbackasm1(SB)
MOVV $818, R12
JMP callbackasm1(SB)
MOVV $819, R12
JMP callbackasm1(SB)
MOVV $820, R12
JMP callbackasm1(SB)
MOVV $821, R12
JMP callbackasm1(SB)
MOVV $822, R12
JMP callbackasm1(SB)
MOVV $823, R12
JMP callbackasm1(SB)
MOVV $824, R12
JMP callbackasm1(SB)
MOVV $825, R12
JMP callbackasm1(SB)
MOVV $826, R12
JMP callbackasm1(SB)
MOVV $827, R12
JMP callbackasm1(SB)
MOVV $828, R12
JMP callbackasm1(SB)
MOVV $829, R12
JMP callbackasm1(SB)
MOVV $830, R12
JMP callbackasm1(SB)
MOVV $831, R12
JMP callbackasm1(SB)
MOVV $832, R12
JMP callbackasm1(SB)
MOVV $833, R12
JMP callbackasm1(SB)
MOVV $834, R12
JMP callbackasm1(SB)
MOVV $835, R12
JMP callbackasm1(SB)
MOVV $836, R12
JMP callbackasm1(SB)
MOVV $837, R12
JMP callbackasm1(SB)
MOVV $838, R12
JMP callbackasm1(SB)
MOVV $839, R12
JMP callbackasm1(SB)
MOVV $840, R12
JMP callbackasm1(SB)
MOVV $841, R12
JMP callbackasm1(SB)
MOVV $842, R12
JMP callbackasm1(SB)
MOVV $843, R12
JMP callbackasm1(SB)
MOVV $844, R12
JMP callbackasm1(SB)
MOVV $845, R12
JMP callbackasm1(SB)
MOVV $846, R12
JMP callbackasm1(SB)
MOVV $847, R12
JMP callbackasm1(SB)
MOVV $848, R12
JMP callbackasm1(SB)
MOVV $849, R12
JMP callbackasm1(SB)
MOVV $850, R12
JMP callbackasm1(SB)
MOVV $851, R12
JMP callbackasm1(SB)
MOVV $852, R12
JMP callbackasm1(SB)
MOVV $853, R12
JMP callbackasm1(SB)
MOVV $854, R12
JMP callbackasm1(SB)
MOVV $855, R12
JMP callbackasm1(SB)
MOVV $856, R12
JMP callbackasm1(SB)
MOVV $857, R12
JMP callbackasm1(SB)
MOVV $858, R12
JMP callbackasm1(SB)
MOVV $859, R12
JMP callbackasm1(SB)
MOVV $860, R12
JMP callbackasm1(SB)
MOVV $861, R12
JMP callbackasm1(SB)
MOVV $862, R12
JMP callbackasm1(SB)
MOVV $863, R12
JMP callbackasm1(SB)
MOVV $864, R12
JMP callbackasm1(SB)
MOVV $865, R12
JMP callbackasm1(SB)
MOVV $866, R12
JMP callbackasm1(SB)
MOVV $867, R12
JMP callbackasm1(SB)
MOVV $868, R12
JMP callbackasm1(SB)
MOVV $869, R12
JMP callbackasm1(SB)
MOVV $870, R12
JMP callbackasm1(SB)
MOVV $871, R12
JMP callbackasm1(SB)
MOVV $872, R12
JMP callbackasm1(SB)
MOVV $873, R12
JMP callbackasm1(SB)
MOVV $874, R12
JMP callbackasm1(SB)
MOVV $875, R12
JMP callbackasm1(SB)
MOVV $876, R12
JMP callbackasm1(SB)
MOVV $877, R12
JMP callbackasm1(SB)
MOVV $878, R12
JMP callbackasm1(SB)
MOVV $879, R12
JMP callbackasm1(SB)
MOVV $880, R12
JMP callbackasm1(SB)
MOVV $881, R12
JMP callbackasm1(SB)
MOVV $882, R12
JMP callbackasm1(SB)
MOVV $883, R12
JMP callbackasm1(SB)
MOVV $884, R12
JMP callbackasm1(SB)
MOVV $885, R12
JMP callbackasm1(SB)
MOVV $886, R12
JMP callbackasm1(SB)
MOVV $887, R12
JMP callbackasm1(SB)
MOVV $888, R12
JMP callbackasm1(SB)
MOVV $889, R12
JMP callbackasm1(SB)
MOVV $890, R12
JMP callbackasm1(SB)
MOVV $891, R12
JMP callbackasm1(SB)
MOVV $892, R12
JMP callbackasm1(SB)
MOVV $893, R12
JMP callbackasm1(SB)
MOVV $894, R12
JMP callbackasm1(SB)
MOVV $895, R12
JMP callbackasm1(SB)
MOVV $896, R12
JMP callbackasm1(SB)
MOVV $897, R12
JMP callbackasm1(SB)
MOVV $898, R12
JMP callbackasm1(SB)
MOVV $899, R12
JMP callbackasm1(SB)
MOVV $900, R12
JMP callbackasm1(SB)
MOVV $901, R12
JMP callbackasm1(SB)
MOVV $902, R12
JMP callbackasm1(SB)
MOVV $903, R12
JMP callbackasm1(SB)
MOVV $904, R12
JMP callbackasm1(SB)
MOVV $905, R12
JMP callbackasm1(SB)
MOVV $906, R12
JMP callbackasm1(SB)
MOVV $907, R12
JMP callbackasm1(SB)
MOVV $908, R12
JMP callbackasm1(SB)
MOVV $909, R12
JMP callbackasm1(SB)
MOVV $910, R12
JMP callbackasm1(SB)
MOVV $911, R12
JMP callbackasm1(SB)
MOVV $912, R12
JMP callbackasm1(SB)
MOVV $913, R12
JMP callbackasm1(SB)
MOVV $914, R12
JMP callbackasm1(SB)
MOVV $915, R12
JMP callbackasm1(SB)
MOVV $916, R12
JMP callbackasm1(SB)
MOVV $917, R12
JMP callbackasm1(SB)
MOVV $918, R12
JMP callbackasm1(SB)
MOVV $919, R12
JMP callbackasm1(SB)
MOVV $920, R12
JMP callbackasm1(SB)
MOVV $921, R12
JMP callbackasm1(SB)
MOVV $922, R12
JMP callbackasm1(SB)
MOVV $923, R12
JMP callbackasm1(SB)
MOVV $924, R12
JMP callbackasm1(SB)
MOVV $925, R12
JMP callbackasm1(SB)
MOVV $926, R12
JMP callbackasm1(SB)
MOVV $927, R12
JMP callbackasm1(SB)
MOVV $928, R12
JMP callbackasm1(SB)
MOVV $929, R12
JMP callbackasm1(SB)
MOVV $930, R12
JMP callbackasm1(SB)
MOVV $931, R12
JMP callbackasm1(SB)
MOVV $932, R12
JMP callbackasm1(SB)
MOVV $933, R12
JMP callbackasm1(SB)
MOVV $934, R12
JMP callbackasm1(SB)
MOVV $935, R12
JMP callbackasm1(SB)
MOVV $936, R12
JMP callbackasm1(SB)
MOVV $937, R12
JMP callbackasm1(SB)
MOVV $938, R12
JMP callbackasm1(SB)
MOVV $939, R12
JMP callbackasm1(SB)
MOVV $940, R12
JMP callbackasm1(SB)
MOVV $941, R12
JMP callbackasm1(SB)
MOVV $942, R12
JMP callbackasm1(SB)
MOVV $943, R12
JMP callbackasm1(SB)
MOVV $944, R12
JMP callbackasm1(SB)
MOVV $945, R12
JMP callbackasm1(SB)
MOVV $946, R12
JMP callbackasm1(SB)
MOVV $947, R12
JMP callbackasm1(SB)
MOVV $948, R12
JMP callbackasm1(SB)
MOVV $949, R12
JMP callbackasm1(SB)
MOVV $950, R12
JMP callbackasm1(SB)
MOVV $951, R12
JMP callbackasm1(SB)
MOVV $952, R12
JMP callbackasm1(SB)
MOVV $953, R12
JMP callbackasm1(SB)
MOVV $954, R12
JMP callbackasm1(SB)
MOVV $955, R12
JMP callbackasm1(SB)
MOVV $956, R12
JMP callbackasm1(SB)
MOVV $957, R12
JMP callbackasm1(SB)
MOVV $958, R12
JMP callbackasm1(SB)
MOVV $959, R12
JMP callbackasm1(SB)
MOVV $960, R12
JMP callbackasm1(SB)
MOVV $961, R12
JMP callbackasm1(SB)
MOVV $962, R12
JMP callbackasm1(SB)
MOVV $963, R12
JMP callbackasm1(SB)
MOVV $964, R12
JMP callbackasm1(SB)
MOVV $965, R12
JMP callbackasm1(SB)
MOVV $966, R12
JMP callbackasm1(SB)
MOVV $967, R12
JMP callbackasm1(SB)
MOVV $968, R12
JMP callbackasm1(SB)
MOVV $969, R12
JMP callbackasm1(SB)
MOVV $970, R12
JMP callbackasm1(SB)
MOVV $971, R12
JMP callbackasm1(SB)
MOVV $972, R12
JMP callbackasm1(SB)
MOVV $973, R12
JMP callbackasm1(SB)
MOVV $974, R12
JMP callbackasm1(SB)
MOVV $975, R12
JMP callbackasm1(SB)
MOVV $976, R12
JMP callbackasm1(SB)
MOVV $977, R12
JMP callbackasm1(SB)
MOVV $978, R12
JMP callbackasm1(SB)
MOVV $979, R12
JMP callbackasm1(SB)
MOVV $980, R12
JMP callbackasm1(SB)
MOVV $981, R12
JMP callbackasm1(SB)
MOVV $982, R12
JMP callbackasm1(SB)
MOVV $983, R12
JMP callbackasm1(SB)
MOVV $984, R12
JMP callbackasm1(SB)
MOVV $985, R12
JMP callbackasm1(SB)
MOVV $986, R12
JMP callbackasm1(SB)
MOVV $987, R12
JMP callbackasm1(SB)
MOVV $988, R12
JMP callbackasm1(SB)
MOVV $989, R12
JMP callbackasm1(SB)
MOVV $990, R12
JMP callbackasm1(SB)
MOVV $991, R12
JMP callbackasm1(SB)
MOVV $992, R12
JMP callbackasm1(SB)
MOVV $993, R12
JMP callbackasm1(SB)
MOVV $994, R12
JMP callbackasm1(SB)
MOVV $995, R12
JMP callbackasm1(SB)
MOVV $996, R12
JMP callbackasm1(SB)
MOVV $997, R12
JMP callbackasm1(SB)
MOVV $998, R12
JMP callbackasm1(SB)
MOVV $999, R12
JMP callbackasm1(SB)
MOVV $1000, R12
JMP callbackasm1(SB)
MOVV $1001, R12
JMP callbackasm1(SB)
MOVV $1002, R12
JMP callbackasm1(SB)
MOVV $1003, R12
JMP callbackasm1(SB)
MOVV $1004, R12
JMP callbackasm1(SB)
MOVV $1005, R12
JMP callbackasm1(SB)
MOVV $1006, R12
JMP callbackasm1(SB)
MOVV $1007, R12
JMP callbackasm1(SB)
MOVV $1008, R12
JMP callbackasm1(SB)
MOVV $1009, R12
JMP callbackasm1(SB)
MOVV $1010, R12
JMP callbackasm1(SB)
MOVV $1011, R12
JMP callbackasm1(SB)
MOVV $1012, R12
JMP callbackasm1(SB)
MOVV $1013, R12
JMP callbackasm1(SB)
MOVV $1014, R12
JMP callbackasm1(SB)
MOVV $1015, R12
JMP callbackasm1(SB)
MOVV $1016, R12
JMP callbackasm1(SB)
MOVV $1017, R12
JMP callbackasm1(SB)
MOVV $1018, R12
JMP callbackasm1(SB)
MOVV $1019, R12
JMP callbackasm1(SB)
MOVV $1020, R12
JMP callbackasm1(SB)
MOVV $1021, R12
JMP callbackasm1(SB)
MOVV $1022, R12
JMP callbackasm1(SB)
MOVV $1023, R12
JMP callbackasm1(SB)
MOVV $1024, R12
JMP callbackasm1(SB)
MOVV $1025, R12
JMP callbackasm1(SB)
MOVV $1026, R12
JMP callbackasm1(SB)
MOVV $1027, R12
JMP callbackasm1(SB)
MOVV $1028, R12
JMP callbackasm1(SB)
MOVV $1029, R12
JMP callbackasm1(SB)
MOVV $1030, R12
JMP callbackasm1(SB)
MOVV $1031, R12
JMP callbackasm1(SB)
MOVV $1032, R12
JMP callbackasm1(SB)
MOVV $1033, R12
JMP callbackasm1(SB)
MOVV $1034, R12
JMP callbackasm1(SB)
MOVV $1035, R12
JMP callbackasm1(SB)
MOVV $1036, R12
JMP callbackasm1(SB)
MOVV $1037, R12
JMP callbackasm1(SB)
MOVV $1038, R12
JMP callbackasm1(SB)
MOVV $1039, R12
JMP callbackasm1(SB)
MOVV $1040, R12
JMP callbackasm1(SB)
MOVV $1041, R12
JMP callbackasm1(SB)
MOVV $1042, R12
JMP callbackasm1(SB)
MOVV $1043, R12
JMP callbackasm1(SB)
MOVV $1044, R12
JMP callbackasm1(SB)
MOVV $1045, R12
JMP callbackasm1(SB)
MOVV $1046, R12
JMP callbackasm1(SB)
MOVV $1047, R12
JMP callbackasm1(SB)
MOVV $1048, R12
JMP callbackasm1(SB)
MOVV $1049, R12
JMP callbackasm1(SB)
MOVV $1050, R12
JMP callbackasm1(SB)
MOVV $1051, R12
JMP callbackasm1(SB)
MOVV $1052, R12
JMP callbackasm1(SB)
MOVV $1053, R12
JMP callbackasm1(SB)
MOVV $1054, R12
JMP callbackasm1(SB)
MOVV $1055, R12
JMP callbackasm1(SB)
MOVV $1056, R12
JMP callbackasm1(SB)
MOVV $1057, R12
JMP callbackasm1(SB)
MOVV $1058, R12
JMP callbackasm1(SB)
MOVV $1059, R12
JMP callbackasm1(SB)
MOVV $1060, R12
JMP callbackasm1(SB)
MOVV $1061, R12
JMP callbackasm1(SB)
MOVV $1062, R12
JMP callbackasm1(SB)
MOVV $1063, R12
JMP callbackasm1(SB)
MOVV $1064, R12
JMP callbackasm1(SB)
MOVV $1065, R12
JMP callbackasm1(SB)
MOVV $1066, R12
JMP callbackasm1(SB)
MOVV $1067, R12
JMP callbackasm1(SB)
MOVV $1068, R12
JMP callbackasm1(SB)
MOVV $1069, R12
JMP callbackasm1(SB)
MOVV $1070, R12
JMP callbackasm1(SB)
MOVV $1071, R12
JMP callbackasm1(SB)
MOVV $1072, R12
JMP callbackasm1(SB)
MOVV $1073, R12
JMP callbackasm1(SB)
MOVV $1074, R12
JMP callbackasm1(SB)
MOVV $1075, R12
JMP callbackasm1(SB)
MOVV $1076, R12
JMP callbackasm1(SB)
MOVV $1077, R12
JMP callbackasm1(SB)
MOVV $1078, R12
JMP callbackasm1(SB)
MOVV $1079, R12
JMP callbackasm1(SB)
MOVV $1080, R12
JMP callbackasm1(SB)
MOVV $1081, R12
JMP callbackasm1(SB)
MOVV $1082, R12
JMP callbackasm1(SB)
MOVV $1083, R12
JMP callbackasm1(SB)
MOVV $1084, R12
JMP callbackasm1(SB)
MOVV $1085, R12
JMP callbackasm1(SB)
MOVV $1086, R12
JMP callbackasm1(SB)
MOVV $1087, R12
JMP callbackasm1(SB)
MOVV $1088, R12
JMP callbackasm1(SB)
MOVV $1089, R12
JMP callbackasm1(SB)
MOVV $1090, R12
JMP callbackasm1(SB)
MOVV $1091, R12
JMP callbackasm1(SB)
MOVV $1092, R12
JMP callbackasm1(SB)
MOVV $1093, R12
JMP callbackasm1(SB)
MOVV $1094, R12
JMP callbackasm1(SB)
MOVV $1095, R12
JMP callbackasm1(SB)
MOVV $1096, R12
JMP callbackasm1(SB)
MOVV $1097, R12
JMP callbackasm1(SB)
MOVV $1098, R12
JMP callbackasm1(SB)
MOVV $1099, R12
JMP callbackasm1(SB)
MOVV $1100, R12
JMP callbackasm1(SB)
MOVV $1101, R12
JMP callbackasm1(SB)
MOVV $1102, R12
JMP callbackasm1(SB)
MOVV $1103, R12
JMP callbackasm1(SB)
MOVV $1104, R12
JMP callbackasm1(SB)
MOVV $1105, R12
JMP callbackasm1(SB)
MOVV $1106, R12
JMP callbackasm1(SB)
MOVV $1107, R12
JMP callbackasm1(SB)
MOVV $1108, R12
JMP callbackasm1(SB)
MOVV $1109, R12
JMP callbackasm1(SB)
MOVV $1110, R12
JMP callbackasm1(SB)
MOVV $1111, R12
JMP callbackasm1(SB)
MOVV $1112, R12
JMP callbackasm1(SB)
MOVV $1113, R12
JMP callbackasm1(SB)
MOVV $1114, R12
JMP callbackasm1(SB)
MOVV $1115, R12
JMP callbackasm1(SB)
MOVV $1116, R12
JMP callbackasm1(SB)
MOVV $1117, R12
JMP callbackasm1(SB)
MOVV $1118, R12
JMP callbackasm1(SB)
MOVV $1119, R12
JMP callbackasm1(SB)
MOVV $1120, R12
JMP callbackasm1(SB)
MOVV $1121, R12
JMP callbackasm1(SB)
MOVV $1122, R12
JMP callbackasm1(SB)
MOVV $1123, R12
JMP callbackasm1(SB)
MOVV $1124, R12
JMP callbackasm1(SB)
MOVV $1125, R12
JMP callbackasm1(SB)
MOVV $1126, R12
JMP callbackasm1(SB)
MOVV $1127, R12
JMP callbackasm1(SB)
MOVV $1128, R12
JMP callbackasm1(SB)
MOVV $1129, R12
JMP callbackasm1(SB)
MOVV $1130, R12
JMP callbackasm1(SB)
MOVV $1131, R12
JMP callbackasm1(SB)
MOVV $1132, R12
JMP callbackasm1(SB)
MOVV $1133, R12
JMP callbackasm1(SB)
MOVV $1134, R12
JMP callbackasm1(SB)
MOVV $1135, R12
JMP callbackasm1(SB)
MOVV $1136, R12
JMP callbackasm1(SB)
MOVV $1137, R12
JMP callbackasm1(SB)
MOVV $1138, R12
JMP callbackasm1(SB)
MOVV $1139, R12
JMP callbackasm1(SB)
MOVV $1140, R12
JMP callbackasm1(SB)
MOVV $1141, R12
JMP callbackasm1(SB)
MOVV $1142, R12
JMP callbackasm1(SB)
MOVV $1143, R12
JMP callbackasm1(SB)
MOVV $1144, R12
JMP callbackasm1(SB)
MOVV $1145, R12
JMP callbackasm1(SB)
MOVV $1146, R12
JMP callbackasm1(SB)
MOVV $1147, R12
JMP callbackasm1(SB)
MOVV $1148, R12
JMP callbackasm1(SB)
MOVV $1149, R12
JMP callbackasm1(SB)
MOVV $1150, R12
JMP callbackasm1(SB)
MOVV $1151, R12
JMP callbackasm1(SB)
MOVV $1152, R12
JMP callbackasm1(SB)
MOVV $1153, R12
JMP callbackasm1(SB)
MOVV $1154, R12
JMP callbackasm1(SB)
MOVV $1155, R12
JMP callbackasm1(SB)
MOVV $1156, R12
JMP callbackasm1(SB)
MOVV $1157, R12
JMP callbackasm1(SB)
MOVV $1158, R12
JMP callbackasm1(SB)
MOVV $1159, R12
JMP callbackasm1(SB)
MOVV $1160, R12
JMP callbackasm1(SB)
MOVV $1161, R12
JMP callbackasm1(SB)
MOVV $1162, R12
JMP callbackasm1(SB)
MOVV $1163, R12
JMP callbackasm1(SB)
MOVV $1164, R12
JMP callbackasm1(SB)
MOVV $1165, R12
JMP callbackasm1(SB)
MOVV $1166, R12
JMP callbackasm1(SB)
MOVV $1167, R12
JMP callbackasm1(SB)
MOVV $1168, R12
JMP callbackasm1(SB)
MOVV $1169, R12
JMP callbackasm1(SB)
MOVV $1170, R12
JMP callbackasm1(SB)
MOVV $1171, R12
JMP callbackasm1(SB)
MOVV $1172, R12
JMP callbackasm1(SB)
MOVV $1173, R12
JMP callbackasm1(SB)
MOVV $1174, R12
JMP callbackasm1(SB)
MOVV $1175, R12
JMP callbackasm1(SB)
MOVV $1176, R12
JMP callbackasm1(SB)
MOVV $1177, R12
JMP callbackasm1(SB)
MOVV $1178, R12
JMP callbackasm1(SB)
MOVV $1179, R12
JMP callbackasm1(SB)
MOVV $1180, R12
JMP callbackasm1(SB)
MOVV $1181, R12
JMP callbackasm1(SB)
MOVV $1182, R12
JMP callbackasm1(SB)
MOVV $1183, R12
JMP callbackasm1(SB)
MOVV $1184, R12
JMP callbackasm1(SB)
MOVV $1185, R12
JMP callbackasm1(SB)
MOVV $1186, R12
JMP callbackasm1(SB)
MOVV $1187, R12
JMP callbackasm1(SB)
MOVV $1188, R12
JMP callbackasm1(SB)
MOVV $1189, R12
JMP callbackasm1(SB)
MOVV $1190, R12
JMP callbackasm1(SB)
MOVV $1191, R12
JMP callbackasm1(SB)
MOVV $1192, R12
JMP callbackasm1(SB)
MOVV $1193, R12
JMP callbackasm1(SB)
MOVV $1194, R12
JMP callbackasm1(SB)
MOVV $1195, R12
JMP callbackasm1(SB)
MOVV $1196, R12
JMP callbackasm1(SB)
MOVV $1197, R12
JMP callbackasm1(SB)
MOVV $1198, R12
JMP callbackasm1(SB)
MOVV $1199, R12
JMP callbackasm1(SB)
MOVV $1200, R12
JMP callbackasm1(SB)
MOVV $1201, R12
JMP callbackasm1(SB)
MOVV $1202, R12
JMP callbackasm1(SB)
MOVV $1203, R12
JMP callbackasm1(SB)
MOVV $1204, R12
JMP callbackasm1(SB)
MOVV $1205, R12
JMP callbackasm1(SB)
MOVV $1206, R12
JMP callbackasm1(SB)
MOVV $1207, R12
JMP callbackasm1(SB)
MOVV $1208, R12
JMP callbackasm1(SB)
MOVV $1209, R12
JMP callbackasm1(SB)
MOVV $1210, R12
JMP callbackasm1(SB)
MOVV $1211, R12
JMP callbackasm1(SB)
MOVV $1212, R12
JMP callbackasm1(SB)
MOVV $1213, R12
JMP callbackasm1(SB)
MOVV $1214, R12
JMP callbackasm1(SB)
MOVV $1215, R12
JMP callbackasm1(SB)
MOVV $1216, R12
JMP callbackasm1(SB)
MOVV $1217, R12
JMP callbackasm1(SB)
MOVV $1218, R12
JMP callbackasm1(SB)
MOVV $1219, R12
JMP callbackasm1(SB)
MOVV $1220, R12
JMP callbackasm1(SB)
MOVV $1221, R12
JMP callbackasm1(SB)
MOVV $1222, R12
JMP callbackasm1(SB)
MOVV $1223, R12
JMP callbackasm1(SB)
MOVV $1224, R12
JMP callbackasm1(SB)
MOVV $1225, R12
JMP callbackasm1(SB)
MOVV $1226, R12
JMP callbackasm1(SB)
MOVV $1227, R12
JMP callbackasm1(SB)
MOVV $1228, R12
JMP callbackasm1(SB)
MOVV $1229, R12
JMP callbackasm1(SB)
MOVV $1230, R12
JMP callbackasm1(SB)
MOVV $1231, R12
JMP callbackasm1(SB)
MOVV $1232, R12
JMP callbackasm1(SB)
MOVV $1233, R12
JMP callbackasm1(SB)
MOVV $1234, R12
JMP callbackasm1(SB)
MOVV $1235, R12
JMP callbackasm1(SB)
MOVV $1236, R12
JMP callbackasm1(SB)
MOVV $1237, R12
JMP callbackasm1(SB)
MOVV $1238, R12
JMP callbackasm1(SB)
MOVV $1239, R12
JMP callbackasm1(SB)
MOVV $1240, R12
JMP callbackasm1(SB)
MOVV $1241, R12
JMP callbackasm1(SB)
MOVV $1242, R12
JMP callbackasm1(SB)
MOVV $1243, R12
JMP callbackasm1(SB)
MOVV $1244, R12
JMP callbackasm1(SB)
MOVV $1245, R12
JMP callbackasm1(SB)
MOVV $1246, R12
JMP callbackasm1(SB)
MOVV $1247, R12
JMP callbackasm1(SB)
MOVV $1248, R12
JMP callbackasm1(SB)
MOVV $1249, R12
JMP callbackasm1(SB)
MOVV $1250, R12
JMP callbackasm1(SB)
MOVV $1251, R12
JMP callbackasm1(SB)
MOVV $1252, R12
JMP callbackasm1(SB)
MOVV $1253, R12
JMP callbackasm1(SB)
MOVV $1254, R12
JMP callbackasm1(SB)
MOVV $1255, R12
JMP callbackasm1(SB)
MOVV $1256, R12
JMP callbackasm1(SB)
MOVV $1257, R12
JMP callbackasm1(SB)
MOVV $1258, R12
JMP callbackasm1(SB)
MOVV $1259, R12
JMP callbackasm1(SB)
MOVV $1260, R12
JMP callbackasm1(SB)
MOVV $1261, R12
JMP callbackasm1(SB)
MOVV $1262, R12
JMP callbackasm1(SB)
MOVV $1263, R12
JMP callbackasm1(SB)
MOVV $1264, R12
JMP callbackasm1(SB)
MOVV $1265, R12
JMP callbackasm1(SB)
MOVV $1266, R12
JMP callbackasm1(SB)
MOVV $1267, R12
JMP callbackasm1(SB)
MOVV $1268, R12
JMP callbackasm1(SB)
MOVV $1269, R12
JMP callbackasm1(SB)
MOVV $1270, R12
JMP callbackasm1(SB)
MOVV $1271, R12
JMP callbackasm1(SB)
MOVV $1272, R12
JMP callbackasm1(SB)
MOVV $1273, R12
JMP callbackasm1(SB)
MOVV $1274, R12
JMP callbackasm1(SB)
MOVV $1275, R12
JMP callbackasm1(SB)
MOVV $1276, R12
JMP callbackasm1(SB)
MOVV $1277, R12
JMP callbackasm1(SB)
MOVV $1278, R12
JMP callbackasm1(SB)
MOVV $1279, R12
JMP callbackasm1(SB)
MOVV $1280, R12
JMP callbackasm1(SB)
MOVV $1281, R12
JMP callbackasm1(SB)
MOVV $1282, R12
JMP callbackasm1(SB)
MOVV $1283, R12
JMP callbackasm1(SB)
MOVV $1284, R12
JMP callbackasm1(SB)
MOVV $1285, R12
JMP callbackasm1(SB)
MOVV $1286, R12
JMP callbackasm1(SB)
MOVV $1287, R12
JMP callbackasm1(SB)
MOVV $1288, R12
JMP callbackasm1(SB)
MOVV $1289, R12
JMP callbackasm1(SB)
MOVV $1290, R12
JMP callbackasm1(SB)
MOVV $1291, R12
JMP callbackasm1(SB)
MOVV $1292, R12
JMP callbackasm1(SB)
MOVV $1293, R12
JMP callbackasm1(SB)
MOVV $1294, R12
JMP callbackasm1(SB)
MOVV $1295, R12
JMP callbackasm1(SB)
MOVV $1296, R12
JMP callbackasm1(SB)
MOVV $1297, R12
JMP callbackasm1(SB)
MOVV $1298, R12
JMP callbackasm1(SB)
MOVV $1299, R12
JMP callbackasm1(SB)
MOVV $1300, R12
JMP callbackasm1(SB)
MOVV $1301, R12
JMP callbackasm1(SB)
MOVV $1302, R12
JMP callbackasm1(SB)
MOVV $1303, R12
JMP callbackasm1(SB)
MOVV $1304, R12
JMP callbackasm1(SB)
MOVV $1305, R12
JMP callbackasm1(SB)
MOVV $1306, R12
JMP callbackasm1(SB)
MOVV $1307, R12
JMP callbackasm1(SB)
MOVV $1308, R12
JMP callbackasm1(SB)
MOVV $1309, R12
JMP callbackasm1(SB)
MOVV $1310, R12
JMP callbackasm1(SB)
MOVV $1311, R12
JMP callbackasm1(SB)
MOVV $1312, R12
JMP callbackasm1(SB)
MOVV $1313, R12
JMP callbackasm1(SB)
MOVV $1314, R12
JMP callbackasm1(SB)
MOVV $1315, R12
JMP callbackasm1(SB)
MOVV $1316, R12
JMP callbackasm1(SB)
MOVV $1317, R12
JMP callbackasm1(SB)
MOVV $1318, R12
JMP callbackasm1(SB)
MOVV $1319, R12
JMP callbackasm1(SB)
MOVV $1320, R12
JMP callbackasm1(SB)
MOVV $1321, R12
JMP callbackasm1(SB)
MOVV $1322, R12
JMP callbackasm1(SB)
MOVV $1323, R12
JMP callbackasm1(SB)
MOVV $1324, R12
JMP callbackasm1(SB)
MOVV $1325, R12
JMP callbackasm1(SB)
MOVV $1326, R12
JMP callbackasm1(SB)
MOVV $1327, R12
JMP callbackasm1(SB)
MOVV $1328, R12
JMP callbackasm1(SB)
MOVV $1329, R12
JMP callbackasm1(SB)
MOVV $1330, R12
JMP callbackasm1(SB)
MOVV $1331, R12
JMP callbackasm1(SB)
MOVV $1332, R12
JMP callbackasm1(SB)
MOVV $1333, R12
JMP callbackasm1(SB)
MOVV $1334, R12
JMP callbackasm1(SB)
MOVV $1335, R12
JMP callbackasm1(SB)
MOVV $1336, R12
JMP callbackasm1(SB)
MOVV $1337, R12
JMP callbackasm1(SB)
MOVV $1338, R12
JMP callbackasm1(SB)
MOVV $1339, R12
JMP callbackasm1(SB)
MOVV $1340, R12
JMP callbackasm1(SB)
MOVV $1341, R12
JMP callbackasm1(SB)
MOVV $1342, R12
JMP callbackasm1(SB)
MOVV $1343, R12
JMP callbackasm1(SB)
MOVV $1344, R12
JMP callbackasm1(SB)
MOVV $1345, R12
JMP callbackasm1(SB)
MOVV $1346, R12
JMP callbackasm1(SB)
MOVV $1347, R12
JMP callbackasm1(SB)
MOVV $1348, R12
JMP callbackasm1(SB)
MOVV $1349, R12
JMP callbackasm1(SB)
MOVV $1350, R12
JMP callbackasm1(SB)
MOVV $1351, R12
JMP callbackasm1(SB)
MOVV $1352, R12
JMP callbackasm1(SB)
MOVV $1353, R12
JMP callbackasm1(SB)
MOVV $1354, R12
JMP callbackasm1(SB)
MOVV $1355, R12
JMP callbackasm1(SB)
MOVV $1356, R12
JMP callbackasm1(SB)
MOVV $1357, R12
JMP callbackasm1(SB)
MOVV $1358, R12
JMP callbackasm1(SB)
MOVV $1359, R12
JMP callbackasm1(SB)
MOVV $1360, R12
JMP callbackasm1(SB)
MOVV $1361, R12
JMP callbackasm1(SB)
MOVV $1362, R12
JMP callbackasm1(SB)
MOVV $1363, R12
JMP callbackasm1(SB)
MOVV $1364, R12
JMP callbackasm1(SB)
MOVV $1365, R12
JMP callbackasm1(SB)
MOVV $1366, R12
JMP callbackasm1(SB)
MOVV $1367, R12
JMP callbackasm1(SB)
MOVV $1368, R12
JMP callbackasm1(SB)
MOVV $1369, R12
JMP callbackasm1(SB)
MOVV $1370, R12
JMP callbackasm1(SB)
MOVV $1371, R12
JMP callbackasm1(SB)
MOVV $1372, R12
JMP callbackasm1(SB)
MOVV $1373, R12
JMP callbackasm1(SB)
MOVV $1374, R12
JMP callbackasm1(SB)
MOVV $1375, R12
JMP callbackasm1(SB)
MOVV $1376, R12
JMP callbackasm1(SB)
MOVV $1377, R12
JMP callbackasm1(SB)
MOVV $1378, R12
JMP callbackasm1(SB)
MOVV $1379, R12
JMP callbackasm1(SB)
MOVV $1380, R12
JMP callbackasm1(SB)
MOVV $1381, R12
JMP callbackasm1(SB)
MOVV $1382, R12
JMP callbackasm1(SB)
MOVV $1383, R12
JMP callbackasm1(SB)
MOVV $1384, R12
JMP callbackasm1(SB)
MOVV $1385, R12
JMP callbackasm1(SB)
MOVV $1386, R12
JMP callbackasm1(SB)
MOVV $1387, R12
JMP callbackasm1(SB)
MOVV $1388, R12
JMP callbackasm1(SB)
MOVV $1389, R12
JMP callbackasm1(SB)
MOVV $1390, R12
JMP callbackasm1(SB)
MOVV $1391, R12
JMP callbackasm1(SB)
MOVV $1392, R12
JMP callbackasm1(SB)
MOVV $1393, R12
JMP callbackasm1(SB)
MOVV $1394, R12
JMP callbackasm1(SB)
MOVV $1395, R12
JMP callbackasm1(SB)
MOVV $1396, R12
JMP callbackasm1(SB)
MOVV $1397, R12
JMP callbackasm1(SB)
MOVV $1398, R12
JMP callbackasm1(SB)
MOVV $1399, R12
JMP callbackasm1(SB)
MOVV $1400, R12
JMP callbackasm1(SB)
MOVV $1401, R12
JMP callbackasm1(SB)
MOVV $1402, R12
JMP callbackasm1(SB)
MOVV $1403, R12
JMP callbackasm1(SB)
MOVV $1404, R12
JMP callbackasm1(SB)
MOVV $1405, R12
JMP callbackasm1(SB)
MOVV $1406, R12
JMP callbackasm1(SB)
MOVV $1407, R12
JMP callbackasm1(SB)
MOVV $1408, R12
JMP callbackasm1(SB)
MOVV $1409, R12
JMP callbackasm1(SB)
MOVV $1410, R12
JMP callbackasm1(SB)
MOVV $1411, R12
JMP callbackasm1(SB)
MOVV $1412, R12
JMP callbackasm1(SB)
MOVV $1413, R12
JMP callbackasm1(SB)
MOVV $1414, R12
JMP callbackasm1(SB)
MOVV $1415, R12
JMP callbackasm1(SB)
MOVV $1416, R12
JMP callbackasm1(SB)
MOVV $1417, R12
JMP callbackasm1(SB)
MOVV $1418, R12
JMP callbackasm1(SB)
MOVV $1419, R12
JMP callbackasm1(SB)
MOVV $1420, R12
JMP callbackasm1(SB)
MOVV $1421, R12
JMP callbackasm1(SB)
MOVV $1422, R12
JMP callbackasm1(SB)
MOVV $1423, R12
JMP callbackasm1(SB)
MOVV $1424, R12
JMP callbackasm1(SB)
MOVV $1425, R12
JMP callbackasm1(SB)
MOVV $1426, R12
JMP callbackasm1(SB)
MOVV $1427, R12
JMP callbackasm1(SB)
MOVV $1428, R12
JMP callbackasm1(SB)
MOVV $1429, R12
JMP callbackasm1(SB)
MOVV $1430, R12
JMP callbackasm1(SB)
MOVV $1431, R12
JMP callbackasm1(SB)
MOVV $1432, R12
JMP callbackasm1(SB)
MOVV $1433, R12
JMP callbackasm1(SB)
MOVV $1434, R12
JMP callbackasm1(SB)
MOVV $1435, R12
JMP callbackasm1(SB)
MOVV $1436, R12
JMP callbackasm1(SB)
MOVV $1437, R12
JMP callbackasm1(SB)
MOVV $1438, R12
JMP callbackasm1(SB)
MOVV $1439, R12
JMP callbackasm1(SB)
MOVV $1440, R12
JMP callbackasm1(SB)
MOVV $1441, R12
JMP callbackasm1(SB)
MOVV $1442, R12
JMP callbackasm1(SB)
MOVV $1443, R12
JMP callbackasm1(SB)
MOVV $1444, R12
JMP callbackasm1(SB)
MOVV $1445, R12
JMP callbackasm1(SB)
MOVV $1446, R12
JMP callbackasm1(SB)
MOVV $1447, R12
JMP callbackasm1(SB)
MOVV $1448, R12
JMP callbackasm1(SB)
MOVV $1449, R12
JMP callbackasm1(SB)
MOVV $1450, R12
JMP callbackasm1(SB)
MOVV $1451, R12
JMP callbackasm1(SB)
MOVV $1452, R12
JMP callbackasm1(SB)
MOVV $1453, R12
JMP callbackasm1(SB)
MOVV $1454, R12
JMP callbackasm1(SB)
MOVV $1455, R12
JMP callbackasm1(SB)
MOVV $1456, R12
JMP callbackasm1(SB)
MOVV $1457, R12
JMP callbackasm1(SB)
MOVV $1458, R12
JMP callbackasm1(SB)
MOVV $1459, R12
JMP callbackasm1(SB)
MOVV $1460, R12
JMP callbackasm1(SB)
MOVV $1461, R12
JMP callbackasm1(SB)
MOVV $1462, R12
JMP callbackasm1(SB)
MOVV $1463, R12
JMP callbackasm1(SB)
MOVV $1464, R12
JMP callbackasm1(SB)
MOVV $1465, R12
JMP callbackasm1(SB)
MOVV $1466, R12
JMP callbackasm1(SB)
MOVV $1467, R12
JMP callbackasm1(SB)
MOVV $1468, R12
JMP callbackasm1(SB)
MOVV $1469, R12
JMP callbackasm1(SB)
MOVV $1470, R12
JMP callbackasm1(SB)
MOVV $1471, R12
JMP callbackasm1(SB)
MOVV $1472, R12
JMP callbackasm1(SB)
MOVV $1473, R12
JMP callbackasm1(SB)
MOVV $1474, R12
JMP callbackasm1(SB)
MOVV $1475, R12
JMP callbackasm1(SB)
MOVV $1476, R12
JMP callbackasm1(SB)
MOVV $1477, R12
JMP callbackasm1(SB)
MOVV $1478, R12
JMP callbackasm1(SB)
MOVV $1479, R12
JMP callbackasm1(SB)
MOVV $1480, R12
JMP callbackasm1(SB)
MOVV $1481, R12
JMP callbackasm1(SB)
MOVV $1482, R12
JMP callbackasm1(SB)
MOVV $1483, R12
JMP callbackasm1(SB)
MOVV $1484, R12
JMP callbackasm1(SB)
MOVV $1485, R12
JMP callbackasm1(SB)
MOVV $1486, R12
JMP callbackasm1(SB)
MOVV $1487, R12
JMP callbackasm1(SB)
MOVV $1488, R12
JMP callbackasm1(SB)
MOVV $1489, R12
JMP callbackasm1(SB)
MOVV $1490, R12
JMP callbackasm1(SB)
MOVV $1491, R12
JMP callbackasm1(SB)
MOVV $1492, R12
JMP callbackasm1(SB)
MOVV $1493, R12
JMP callbackasm1(SB)
MOVV $1494, R12
JMP callbackasm1(SB)
MOVV $1495, R12
JMP callbackasm1(SB)
MOVV $1496, R12
JMP callbackasm1(SB)
MOVV $1497, R12
JMP callbackasm1(SB)
MOVV $1498, R12
JMP callbackasm1(SB)
MOVV $1499, R12
JMP callbackasm1(SB)
MOVV $1500, R12
JMP callbackasm1(SB)
MOVV $1501, R12
JMP callbackasm1(SB)
MOVV $1502, R12
JMP callbackasm1(SB)
MOVV $1503, R12
JMP callbackasm1(SB)
MOVV $1504, R12
JMP callbackasm1(SB)
MOVV $1505, R12
JMP callbackasm1(SB)
MOVV $1506, R12
JMP callbackasm1(SB)
MOVV $1507, R12
JMP callbackasm1(SB)
MOVV $1508, R12
JMP callbackasm1(SB)
MOVV $1509, R12
JMP callbackasm1(SB)
MOVV $1510, R12
JMP callbackasm1(SB)
MOVV $1511, R12
JMP callbackasm1(SB)
MOVV $1512, R12
JMP callbackasm1(SB)
MOVV $1513, R12
JMP callbackasm1(SB)
MOVV $1514, R12
JMP callbackasm1(SB)
MOVV $1515, R12
JMP callbackasm1(SB)
MOVV $1516, R12
JMP callbackasm1(SB)
MOVV $1517, R12
JMP callbackasm1(SB)
MOVV $1518, R12
JMP callbackasm1(SB)
MOVV $1519, R12
JMP callbackasm1(SB)
MOVV $1520, R12
JMP callbackasm1(SB)
MOVV $1521, R12
JMP callbackasm1(SB)
MOVV $1522, R12
JMP callbackasm1(SB)
MOVV $1523, R12
JMP callbackasm1(SB)
MOVV $1524, R12
JMP callbackasm1(SB)
MOVV $1525, R12
JMP callbackasm1(SB)
MOVV $1526, R12
JMP callbackasm1(SB)
MOVV $1527, R12
JMP callbackasm1(SB)
MOVV $1528, R12
JMP callbackasm1(SB)
MOVV $1529, R12
JMP callbackasm1(SB)
MOVV $1530, R12
JMP callbackasm1(SB)
MOVV $1531, R12
JMP callbackasm1(SB)
MOVV $1532, R12
JMP callbackasm1(SB)
MOVV $1533, R12
JMP callbackasm1(SB)
MOVV $1534, R12
JMP callbackasm1(SB)
MOVV $1535, R12
JMP callbackasm1(SB)
MOVV $1536, R12
JMP callbackasm1(SB)
MOVV $1537, R12
JMP callbackasm1(SB)
MOVV $1538, R12
JMP callbackasm1(SB)
MOVV $1539, R12
JMP callbackasm1(SB)
MOVV $1540, R12
JMP callbackasm1(SB)
MOVV $1541, R12
JMP callbackasm1(SB)
MOVV $1542, R12
JMP callbackasm1(SB)
MOVV $1543, R12
JMP callbackasm1(SB)
MOVV $1544, R12
JMP callbackasm1(SB)
MOVV $1545, R12
JMP callbackasm1(SB)
MOVV $1546, R12
JMP callbackasm1(SB)
MOVV $1547, R12
JMP callbackasm1(SB)
MOVV $1548, R12
JMP callbackasm1(SB)
MOVV $1549, R12
JMP callbackasm1(SB)
MOVV $1550, R12
JMP callbackasm1(SB)
MOVV $1551, R12
JMP callbackasm1(SB)
MOVV $1552, R12
JMP callbackasm1(SB)
MOVV $1553, R12
JMP callbackasm1(SB)
MOVV $1554, R12
JMP callbackasm1(SB)
MOVV $1555, R12
JMP callbackasm1(SB)
MOVV $1556, R12
JMP callbackasm1(SB)
MOVV $1557, R12
JMP callbackasm1(SB)
MOVV $1558, R12
JMP callbackasm1(SB)
MOVV $1559, R12
JMP callbackasm1(SB)
MOVV $1560, R12
JMP callbackasm1(SB)
MOVV $1561, R12
JMP callbackasm1(SB)
MOVV $1562, R12
JMP callbackasm1(SB)
MOVV $1563, R12
JMP callbackasm1(SB)
MOVV $1564, R12
JMP callbackasm1(SB)
MOVV $1565, R12
JMP callbackasm1(SB)
MOVV $1566, R12
JMP callbackasm1(SB)
MOVV $1567, R12
JMP callbackasm1(SB)
MOVV $1568, R12
JMP callbackasm1(SB)
MOVV $1569, R12
JMP callbackasm1(SB)
MOVV $1570, R12
JMP callbackasm1(SB)
MOVV $1571, R12
JMP callbackasm1(SB)
MOVV $1572, R12
JMP callbackasm1(SB)
MOVV $1573, R12
JMP callbackasm1(SB)
MOVV $1574, R12
JMP callbackasm1(SB)
MOVV $1575, R12
JMP callbackasm1(SB)
MOVV $1576, R12
JMP callbackasm1(SB)
MOVV $1577, R12
JMP callbackasm1(SB)
MOVV $1578, R12
JMP callbackasm1(SB)
MOVV $1579, R12
JMP callbackasm1(SB)
MOVV $1580, R12
JMP callbackasm1(SB)
MOVV $1581, R12
JMP callbackasm1(SB)
MOVV $1582, R12
JMP callbackasm1(SB)
MOVV $1583, R12
JMP callbackasm1(SB)
MOVV $1584, R12
JMP callbackasm1(SB)
MOVV $1585, R12
JMP callbackasm1(SB)
MOVV $1586, R12
JMP callbackasm1(SB)
MOVV $1587, R12
JMP callbackasm1(SB)
MOVV $1588, R12
JMP callbackasm1(SB)
MOVV $1589, R12
JMP callbackasm1(SB)
MOVV $1590, R12
JMP callbackasm1(SB)
MOVV $1591, R12
JMP callbackasm1(SB)
MOVV $1592, R12
JMP callbackasm1(SB)
MOVV $1593, R12
JMP callbackasm1(SB)
MOVV $1594, R12
JMP callbackasm1(SB)
MOVV $1595, R12
JMP callbackasm1(SB)
MOVV $1596, R12
JMP callbackasm1(SB)
MOVV $1597, R12
JMP callbackasm1(SB)
MOVV $1598, R12
JMP callbackasm1(SB)
MOVV $1599, R12
JMP callbackasm1(SB)
MOVV $1600, R12
JMP callbackasm1(SB)
MOVV $1601, R12
JMP callbackasm1(SB)
MOVV $1602, R12
JMP callbackasm1(SB)
MOVV $1603, R12
JMP callbackasm1(SB)
MOVV $1604, R12
JMP callbackasm1(SB)
MOVV $1605, R12
JMP callbackasm1(SB)
MOVV $1606, R12
JMP callbackasm1(SB)
MOVV $1607, R12
JMP callbackasm1(SB)
MOVV $1608, R12
JMP callbackasm1(SB)
MOVV $1609, R12
JMP callbackasm1(SB)
MOVV $1610, R12
JMP callbackasm1(SB)
MOVV $1611, R12
JMP callbackasm1(SB)
MOVV $1612, R12
JMP callbackasm1(SB)
MOVV $1613, R12
JMP callbackasm1(SB)
MOVV $1614, R12
JMP callbackasm1(SB)
MOVV $1615, R12
JMP callbackasm1(SB)
MOVV $1616, R12
JMP callbackasm1(SB)
MOVV $1617, R12
JMP callbackasm1(SB)
MOVV $1618, R12
JMP callbackasm1(SB)
MOVV $1619, R12
JMP callbackasm1(SB)
MOVV $1620, R12
JMP callbackasm1(SB)
MOVV $1621, R12
JMP callbackasm1(SB)
MOVV $1622, R12
JMP callbackasm1(SB)
MOVV $1623, R12
JMP callbackasm1(SB)
MOVV $1624, R12
JMP callbackasm1(SB)
MOVV $1625, R12
JMP callbackasm1(SB)
MOVV $1626, R12
JMP callbackasm1(SB)
MOVV $1627, R12
JMP callbackasm1(SB)
MOVV $1628, R12
JMP callbackasm1(SB)
MOVV $1629, R12
JMP callbackasm1(SB)
MOVV $1630, R12
JMP callbackasm1(SB)
MOVV $1631, R12
JMP callbackasm1(SB)
MOVV $1632, R12
JMP callbackasm1(SB)
MOVV $1633, R12
JMP callbackasm1(SB)
MOVV $1634, R12
JMP callbackasm1(SB)
MOVV $1635, R12
JMP callbackasm1(SB)
MOVV $1636, R12
JMP callbackasm1(SB)
MOVV $1637, R12
JMP callbackasm1(SB)
MOVV $1638, R12
JMP callbackasm1(SB)
MOVV $1639, R12
JMP callbackasm1(SB)
MOVV $1640, R12
JMP callbackasm1(SB)
MOVV $1641, R12
JMP callbackasm1(SB)
MOVV $1642, R12
JMP callbackasm1(SB)
MOVV $1643, R12
JMP callbackasm1(SB)
MOVV $1644, R12
JMP callbackasm1(SB)
MOVV $1645, R12
JMP callbackasm1(SB)
MOVV $1646, R12
JMP callbackasm1(SB)
MOVV $1647, R12
JMP callbackasm1(SB)
MOVV $1648, R12
JMP callbackasm1(SB)
MOVV $1649, R12
JMP callbackasm1(SB)
MOVV $1650, R12
JMP callbackasm1(SB)
MOVV $1651, R12
JMP callbackasm1(SB)
MOVV $1652, R12
JMP callbackasm1(SB)
MOVV $1653, R12
JMP callbackasm1(SB)
MOVV $1654, R12
JMP callbackasm1(SB)
MOVV $1655, R12
JMP callbackasm1(SB)
MOVV $1656, R12
JMP callbackasm1(SB)
MOVV $1657, R12
JMP callbackasm1(SB)
MOVV $1658, R12
JMP callbackasm1(SB)
MOVV $1659, R12
JMP callbackasm1(SB)
MOVV $1660, R12
JMP callbackasm1(SB)
MOVV $1661, R12
JMP callbackasm1(SB)
MOVV $1662, R12
JMP callbackasm1(SB)
MOVV $1663, R12
JMP callbackasm1(SB)
MOVV $1664, R12
JMP callbackasm1(SB)
MOVV $1665, R12
JMP callbackasm1(SB)
MOVV $1666, R12
JMP callbackasm1(SB)
MOVV $1667, R12
JMP callbackasm1(SB)
MOVV $1668, R12
JMP callbackasm1(SB)
MOVV $1669, R12
JMP callbackasm1(SB)
MOVV $1670, R12
JMP callbackasm1(SB)
MOVV $1671, R12
JMP callbackasm1(SB)
MOVV $1672, R12
JMP callbackasm1(SB)
MOVV $1673, R12
JMP callbackasm1(SB)
MOVV $1674, R12
JMP callbackasm1(SB)
MOVV $1675, R12
JMP callbackasm1(SB)
MOVV $1676, R12
JMP callbackasm1(SB)
MOVV $1677, R12
JMP callbackasm1(SB)
MOVV $1678, R12
JMP callbackasm1(SB)
MOVV $1679, R12
JMP callbackasm1(SB)
MOVV $1680, R12
JMP callbackasm1(SB)
MOVV $1681, R12
JMP callbackasm1(SB)
MOVV $1682, R12
JMP callbackasm1(SB)
MOVV $1683, R12
JMP callbackasm1(SB)
MOVV $1684, R12
JMP callbackasm1(SB)
MOVV $1685, R12
JMP callbackasm1(SB)
MOVV $1686, R12
JMP callbackasm1(SB)
MOVV $1687, R12
JMP callbackasm1(SB)
MOVV $1688, R12
JMP callbackasm1(SB)
MOVV $1689, R12
JMP callbackasm1(SB)
MOVV $1690, R12
JMP callbackasm1(SB)
MOVV $1691, R12
JMP callbackasm1(SB)
MOVV $1692, R12
JMP callbackasm1(SB)
MOVV $1693, R12
JMP callbackasm1(SB)
MOVV $1694, R12
JMP callbackasm1(SB)
MOVV $1695, R12
JMP callbackasm1(SB)
MOVV $1696, R12
JMP callbackasm1(SB)
MOVV $1697, R12
JMP callbackasm1(SB)
MOVV $1698, R12
JMP callbackasm1(SB)
MOVV $1699, R12
JMP callbackasm1(SB)
MOVV $1700, R12
JMP callbackasm1(SB)
MOVV $1701, R12
JMP callbackasm1(SB)
MOVV $1702, R12
JMP callbackasm1(SB)
MOVV $1703, R12
JMP callbackasm1(SB)
MOVV $1704, R12
JMP callbackasm1(SB)
MOVV $1705, R12
JMP callbackasm1(SB)
MOVV $1706, R12
JMP callbackasm1(SB)
MOVV $1707, R12
JMP callbackasm1(SB)
MOVV $1708, R12
JMP callbackasm1(SB)
MOVV $1709, R12
JMP callbackasm1(SB)
MOVV $1710, R12
JMP callbackasm1(SB)
MOVV $1711, R12
JMP callbackasm1(SB)
MOVV $1712, R12
JMP callbackasm1(SB)
MOVV $1713, R12
JMP callbackasm1(SB)
MOVV $1714, R12
JMP callbackasm1(SB)
MOVV $1715, R12
JMP callbackasm1(SB)
MOVV $1716, R12
JMP callbackasm1(SB)
MOVV $1717, R12
JMP callbackasm1(SB)
MOVV $1718, R12
JMP callbackasm1(SB)
MOVV $1719, R12
JMP callbackasm1(SB)
MOVV $1720, R12
JMP callbackasm1(SB)
MOVV $1721, R12
JMP callbackasm1(SB)
MOVV $1722, R12
JMP callbackasm1(SB)
MOVV $1723, R12
JMP callbackasm1(SB)
MOVV $1724, R12
JMP callbackasm1(SB)
MOVV $1725, R12
JMP callbackasm1(SB)
MOVV $1726, R12
JMP callbackasm1(SB)
MOVV $1727, R12
JMP callbackasm1(SB)
MOVV $1728, R12
JMP callbackasm1(SB)
MOVV $1729, R12
JMP callbackasm1(SB)
MOVV $1730, R12
JMP callbackasm1(SB)
MOVV $1731, R12
JMP callbackasm1(SB)
MOVV $1732, R12
JMP callbackasm1(SB)
MOVV $1733, R12
JMP callbackasm1(SB)
MOVV $1734, R12
JMP callbackasm1(SB)
MOVV $1735, R12
JMP callbackasm1(SB)
MOVV $1736, R12
JMP callbackasm1(SB)
MOVV $1737, R12
JMP callbackasm1(SB)
MOVV $1738, R12
JMP callbackasm1(SB)
MOVV $1739, R12
JMP callbackasm1(SB)
MOVV $1740, R12
JMP callbackasm1(SB)
MOVV $1741, R12
JMP callbackasm1(SB)
MOVV $1742, R12
JMP callbackasm1(SB)
MOVV $1743, R12
JMP callbackasm1(SB)
MOVV $1744, R12
JMP callbackasm1(SB)
MOVV $1745, R12
JMP callbackasm1(SB)
MOVV $1746, R12
JMP callbackasm1(SB)
MOVV $1747, R12
JMP callbackasm1(SB)
MOVV $1748, R12
JMP callbackasm1(SB)
MOVV $1749, R12
JMP callbackasm1(SB)
MOVV $1750, R12
JMP callbackasm1(SB)
MOVV $1751, R12
JMP callbackasm1(SB)
MOVV $1752, R12
JMP callbackasm1(SB)
MOVV $1753, R12
JMP callbackasm1(SB)
MOVV $1754, R12
JMP callbackasm1(SB)
MOVV $1755, R12
JMP callbackasm1(SB)
MOVV $1756, R12
JMP callbackasm1(SB)
MOVV $1757, R12
JMP callbackasm1(SB)
MOVV $1758, R12
JMP callbackasm1(SB)
MOVV $1759, R12
JMP callbackasm1(SB)
MOVV $1760, R12
JMP callbackasm1(SB)
MOVV $1761, R12
JMP callbackasm1(SB)
MOVV $1762, R12
JMP callbackasm1(SB)
MOVV $1763, R12
JMP callbackasm1(SB)
MOVV $1764, R12
JMP callbackasm1(SB)
MOVV $1765, R12
JMP callbackasm1(SB)
MOVV $1766, R12
JMP callbackasm1(SB)
MOVV $1767, R12
JMP callbackasm1(SB)
MOVV $1768, R12
JMP callbackasm1(SB)
MOVV $1769, R12
JMP callbackasm1(SB)
MOVV $1770, R12
JMP callbackasm1(SB)
MOVV $1771, R12
JMP callbackasm1(SB)
MOVV $1772, R12
JMP callbackasm1(SB)
MOVV $1773, R12
JMP callbackasm1(SB)
MOVV $1774, R12
JMP callbackasm1(SB)
MOVV $1775, R12
JMP callbackasm1(SB)
MOVV $1776, R12
JMP callbackasm1(SB)
MOVV $1777, R12
JMP callbackasm1(SB)
MOVV $1778, R12
JMP callbackasm1(SB)
MOVV $1779, R12
JMP callbackasm1(SB)
MOVV $1780, R12
JMP callbackasm1(SB)
MOVV $1781, R12
JMP callbackasm1(SB)
MOVV $1782, R12
JMP callbackasm1(SB)
MOVV $1783, R12
JMP callbackasm1(SB)
MOVV $1784, R12
JMP callbackasm1(SB)
MOVV $1785, R12
JMP callbackasm1(SB)
MOVV $1786, R12
JMP callbackasm1(SB)
MOVV $1787, R12
JMP callbackasm1(SB)
MOVV $1788, R12
JMP callbackasm1(SB)
MOVV $1789, R12
JMP callbackasm1(SB)
MOVV $1790, R12
JMP callbackasm1(SB)
MOVV $1791, R12
JMP callbackasm1(SB)
MOVV $1792, R12
JMP callbackasm1(SB)
MOVV $1793, R12
JMP callbackasm1(SB)
MOVV $1794, R12
JMP callbackasm1(SB)
MOVV $1795, R12
JMP callbackasm1(SB)
MOVV $1796, R12
JMP callbackasm1(SB)
MOVV $1797, R12
JMP callbackasm1(SB)
MOVV $1798, R12
JMP callbackasm1(SB)
MOVV $1799, R12
JMP callbackasm1(SB)
MOVV $1800, R12
JMP callbackasm1(SB)
MOVV $1801, R12
JMP callbackasm1(SB)
MOVV $1802, R12
JMP callbackasm1(SB)
MOVV $1803, R12
JMP callbackasm1(SB)
MOVV $1804, R12
JMP callbackasm1(SB)
MOVV $1805, R12
JMP callbackasm1(SB)
MOVV $1806, R12
JMP callbackasm1(SB)
MOVV $1807, R12
JMP callbackasm1(SB)
MOVV $1808, R12
JMP callbackasm1(SB)
MOVV $1809, R12
JMP callbackasm1(SB)
MOVV $1810, R12
JMP callbackasm1(SB)
MOVV $1811, R12
JMP callbackasm1(SB)
MOVV $1812, R12
JMP callbackasm1(SB)
MOVV $1813, R12
JMP callbackasm1(SB)
MOVV $1814, R12
JMP callbackasm1(SB)
MOVV $1815, R12
JMP callbackasm1(SB)
MOVV $1816, R12
JMP callbackasm1(SB)
MOVV $1817, R12
JMP callbackasm1(SB)
MOVV $1818, R12
JMP callbackasm1(SB)
MOVV $1819, R12
JMP callbackasm1(SB)
MOVV $1820, R12
JMP callbackasm1(SB)
MOVV $1821, R12
JMP callbackasm1(SB)
MOVV $1822, R12
JMP callbackasm1(SB)
MOVV $1823, R12
JMP callbackasm1(SB)
MOVV $1824, R12
JMP callbackasm1(SB)
MOVV $1825, R12
JMP callbackasm1(SB)
MOVV $1826, R12
JMP callbackasm1(SB)
MOVV $1827, R12
JMP callbackasm1(SB)
MOVV $1828, R12
JMP callbackasm1(SB)
MOVV $1829, R12
JMP callbackasm1(SB)
MOVV $1830, R12
JMP callbackasm1(SB)
MOVV $1831, R12
JMP callbackasm1(SB)
MOVV $1832, R12
JMP callbackasm1(SB)
MOVV $1833, R12
JMP callbackasm1(SB)
MOVV $1834, R12
JMP callbackasm1(SB)
MOVV $1835, R12
JMP callbackasm1(SB)
MOVV $1836, R12
JMP callbackasm1(SB)
MOVV $1837, R12
JMP callbackasm1(SB)
MOVV $1838, R12
JMP callbackasm1(SB)
MOVV $1839, R12
JMP callbackasm1(SB)
MOVV $1840, R12
JMP callbackasm1(SB)
MOVV $1841, R12
JMP callbackasm1(SB)
MOVV $1842, R12
JMP callbackasm1(SB)
MOVV $1843, R12
JMP callbackasm1(SB)
MOVV $1844, R12
JMP callbackasm1(SB)
MOVV $1845, R12
JMP callbackasm1(SB)
MOVV $1846, R12
JMP callbackasm1(SB)
MOVV $1847, R12
JMP callbackasm1(SB)
MOVV $1848, R12
JMP callbackasm1(SB)
MOVV $1849, R12
JMP callbackasm1(SB)
MOVV $1850, R12
JMP callbackasm1(SB)
MOVV $1851, R12
JMP callbackasm1(SB)
MOVV $1852, R12
JMP callbackasm1(SB)
MOVV $1853, R12
JMP callbackasm1(SB)
MOVV $1854, R12
JMP callbackasm1(SB)
MOVV $1855, R12
JMP callbackasm1(SB)
MOVV $1856, R12
JMP callbackasm1(SB)
MOVV $1857, R12
JMP callbackasm1(SB)
MOVV $1858, R12
JMP callbackasm1(SB)
MOVV $1859, R12
JMP callbackasm1(SB)
MOVV $1860, R12
JMP callbackasm1(SB)
MOVV $1861, R12
JMP callbackasm1(SB)
MOVV $1862, R12
JMP callbackasm1(SB)
MOVV $1863, R12
JMP callbackasm1(SB)
MOVV $1864, R12
JMP callbackasm1(SB)
MOVV $1865, R12
JMP callbackasm1(SB)
MOVV $1866, R12
JMP callbackasm1(SB)
MOVV $1867, R12
JMP callbackasm1(SB)
MOVV $1868, R12
JMP callbackasm1(SB)
MOVV $1869, R12
JMP callbackasm1(SB)
MOVV $1870, R12
JMP callbackasm1(SB)
MOVV $1871, R12
JMP callbackasm1(SB)
MOVV $1872, R12
JMP callbackasm1(SB)
MOVV $1873, R12
JMP callbackasm1(SB)
MOVV $1874, R12
JMP callbackasm1(SB)
MOVV $1875, R12
JMP callbackasm1(SB)
MOVV $1876, R12
JMP callbackasm1(SB)
MOVV $1877, R12
JMP callbackasm1(SB)
MOVV $1878, R12
JMP callbackasm1(SB)
MOVV $1879, R12
JMP callbackasm1(SB)
MOVV $1880, R12
JMP callbackasm1(SB)
MOVV $1881, R12
JMP callbackasm1(SB)
MOVV $1882, R12
JMP callbackasm1(SB)
MOVV $1883, R12
JMP callbackasm1(SB)
MOVV $1884, R12
JMP callbackasm1(SB)
MOVV $1885, R12
JMP callbackasm1(SB)
MOVV $1886, R12
JMP callbackasm1(SB)
MOVV $1887, R12
JMP callbackasm1(SB)
MOVV $1888, R12
JMP callbackasm1(SB)
MOVV $1889, R12
JMP callbackasm1(SB)
MOVV $1890, R12
JMP callbackasm1(SB)
MOVV $1891, R12
JMP callbackasm1(SB)
MOVV $1892, R12
JMP callbackasm1(SB)
MOVV $1893, R12
JMP callbackasm1(SB)
MOVV $1894, R12
JMP callbackasm1(SB)
MOVV $1895, R12
JMP callbackasm1(SB)
MOVV $1896, R12
JMP callbackasm1(SB)
MOVV $1897, R12
JMP callbackasm1(SB)
MOVV $1898, R12
JMP callbackasm1(SB)
MOVV $1899, R12
JMP callbackasm1(SB)
MOVV $1900, R12
JMP callbackasm1(SB)
MOVV $1901, R12
JMP callbackasm1(SB)
MOVV $1902, R12
JMP callbackasm1(SB)
MOVV $1903, R12
JMP callbackasm1(SB)
MOVV $1904, R12
JMP callbackasm1(SB)
MOVV $1905, R12
JMP callbackasm1(SB)
MOVV $1906, R12
JMP callbackasm1(SB)
MOVV $1907, R12
JMP callbackasm1(SB)
MOVV $1908, R12
JMP callbackasm1(SB)
MOVV $1909, R12
JMP callbackasm1(SB)
MOVV $1910, R12
JMP callbackasm1(SB)
MOVV $1911, R12
JMP callbackasm1(SB)
MOVV $1912, R12
JMP callbackasm1(SB)
MOVV $1913, R12
JMP callbackasm1(SB)
MOVV $1914, R12
JMP callbackasm1(SB)
MOVV $1915, R12
JMP callbackasm1(SB)
MOVV $1916, R12
JMP callbackasm1(SB)
MOVV $1917, R12
JMP callbackasm1(SB)
MOVV $1918, R12
JMP callbackasm1(SB)
MOVV $1919, R12
JMP callbackasm1(SB)
MOVV $1920, R12
JMP callbackasm1(SB)
MOVV $1921, R12
JMP callbackasm1(SB)
MOVV $1922, R12
JMP callbackasm1(SB)
MOVV $1923, R12
JMP callbackasm1(SB)
MOVV $1924, R12
JMP callbackasm1(SB)
MOVV $1925, R12
JMP callbackasm1(SB)
MOVV $1926, R12
JMP callbackasm1(SB)
MOVV $1927, R12
JMP callbackasm1(SB)
MOVV $1928, R12
JMP callbackasm1(SB)
MOVV $1929, R12
JMP callbackasm1(SB)
MOVV $1930, R12
JMP callbackasm1(SB)
MOVV $1931, R12
JMP callbackasm1(SB)
MOVV $1932, R12
JMP callbackasm1(SB)
MOVV $1933, R12
JMP callbackasm1(SB)
MOVV $1934, R12
JMP callbackasm1(SB)
MOVV $1935, R12
JMP callbackasm1(SB)
MOVV $1936, R12
JMP callbackasm1(SB)
MOVV $1937, R12
JMP callbackasm1(SB)
MOVV $1938, R12
JMP callbackasm1(SB)
MOVV $1939, R12
JMP callbackasm1(SB)
MOVV $1940, R12
JMP callbackasm1(SB)
MOVV $1941, R12
JMP callbackasm1(SB)
MOVV $1942, R12
JMP callbackasm1(SB)
MOVV $1943, R12
JMP callbackasm1(SB)
MOVV $1944, R12
JMP callbackasm1(SB)
MOVV $1945, R12
JMP callbackasm1(SB)
MOVV $1946, R12
JMP callbackasm1(SB)
MOVV $1947, R12
JMP callbackasm1(SB)
MOVV $1948, R12
JMP callbackasm1(SB)
MOVV $1949, R12
JMP callbackasm1(SB)
MOVV $1950, R12
JMP callbackasm1(SB)
MOVV $1951, R12
JMP callbackasm1(SB)
MOVV $1952, R12
JMP callbackasm1(SB)
MOVV $1953, R12
JMP callbackasm1(SB)
MOVV $1954, R12
JMP callbackasm1(SB)
MOVV $1955, R12
JMP callbackasm1(SB)
MOVV $1956, R12
JMP callbackasm1(SB)
MOVV $1957, R12
JMP callbackasm1(SB)
MOVV $1958, R12
JMP callbackasm1(SB)
MOVV $1959, R12
JMP callbackasm1(SB)
MOVV $1960, R12
JMP callbackasm1(SB)
MOVV $1961, R12
JMP callbackasm1(SB)
MOVV $1962, R12
JMP callbackasm1(SB)
MOVV $1963, R12
JMP callbackasm1(SB)
MOVV $1964, R12
JMP callbackasm1(SB)
MOVV $1965, R12
JMP callbackasm1(SB)
MOVV $1966, R12
JMP callbackasm1(SB)
MOVV $1967, R12
JMP callbackasm1(SB)
MOVV $1968, R12
JMP callbackasm1(SB)
MOVV $1969, R12
JMP callbackasm1(SB)
MOVV $1970, R12
JMP callbackasm1(SB)
MOVV $1971, R12
JMP callbackasm1(SB)
MOVV $1972, R12
JMP callbackasm1(SB)
MOVV $1973, R12
JMP callbackasm1(SB)
MOVV $1974, R12
JMP callbackasm1(SB)
MOVV $1975, R12
JMP callbackasm1(SB)
MOVV $1976, R12
JMP callbackasm1(SB)
MOVV $1977, R12
JMP callbackasm1(SB)
MOVV $1978, R12
JMP callbackasm1(SB)
MOVV $1979, R12
JMP callbackasm1(SB)
MOVV $1980, R12
JMP callbackasm1(SB)
MOVV $1981, R12
JMP callbackasm1(SB)
MOVV $1982, R12
JMP callbackasm1(SB)
MOVV $1983, R12
JMP callbackasm1(SB)
MOVV $1984, R12
JMP callbackasm1(SB)
MOVV $1985, R12
JMP callbackasm1(SB)
MOVV $1986, R12
JMP callbackasm1(SB)
MOVV $1987, R12
JMP callbackasm1(SB)
MOVV $1988, R12
JMP callbackasm1(SB)
MOVV $1989, R12
JMP callbackasm1(SB)
MOVV $1990, R12
JMP callbackasm1(SB)
MOVV $1991, R12
JMP callbackasm1(SB)
MOVV $1992, R12
JMP callbackasm1(SB)
MOVV $1993, R12
JMP callbackasm1(SB)
MOVV $1994, R12
JMP callbackasm1(SB)
MOVV $1995, R12
JMP callbackasm1(SB)
MOVV $1996, R12
JMP callbackasm1(SB)
MOVV $1997, R12
JMP callbackasm1(SB)
MOVV $1998, R12
JMP callbackasm1(SB)
MOVV $1999, R12
JMP callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_ppc64le.s 0000664 0000000 0000000 00000233172 15207302613 0023404 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVD and BR instructions.
// The MOVD instruction loads R11 with the callback index, and the
// BR instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R11 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVD $0, R11
BR callbackasm1(SB)
MOVD $1, R11
BR callbackasm1(SB)
MOVD $2, R11
BR callbackasm1(SB)
MOVD $3, R11
BR callbackasm1(SB)
MOVD $4, R11
BR callbackasm1(SB)
MOVD $5, R11
BR callbackasm1(SB)
MOVD $6, R11
BR callbackasm1(SB)
MOVD $7, R11
BR callbackasm1(SB)
MOVD $8, R11
BR callbackasm1(SB)
MOVD $9, R11
BR callbackasm1(SB)
MOVD $10, R11
BR callbackasm1(SB)
MOVD $11, R11
BR callbackasm1(SB)
MOVD $12, R11
BR callbackasm1(SB)
MOVD $13, R11
BR callbackasm1(SB)
MOVD $14, R11
BR callbackasm1(SB)
MOVD $15, R11
BR callbackasm1(SB)
MOVD $16, R11
BR callbackasm1(SB)
MOVD $17, R11
BR callbackasm1(SB)
MOVD $18, R11
BR callbackasm1(SB)
MOVD $19, R11
BR callbackasm1(SB)
MOVD $20, R11
BR callbackasm1(SB)
MOVD $21, R11
BR callbackasm1(SB)
MOVD $22, R11
BR callbackasm1(SB)
MOVD $23, R11
BR callbackasm1(SB)
MOVD $24, R11
BR callbackasm1(SB)
MOVD $25, R11
BR callbackasm1(SB)
MOVD $26, R11
BR callbackasm1(SB)
MOVD $27, R11
BR callbackasm1(SB)
MOVD $28, R11
BR callbackasm1(SB)
MOVD $29, R11
BR callbackasm1(SB)
MOVD $30, R11
BR callbackasm1(SB)
MOVD $31, R11
BR callbackasm1(SB)
MOVD $32, R11
BR callbackasm1(SB)
MOVD $33, R11
BR callbackasm1(SB)
MOVD $34, R11
BR callbackasm1(SB)
MOVD $35, R11
BR callbackasm1(SB)
MOVD $36, R11
BR callbackasm1(SB)
MOVD $37, R11
BR callbackasm1(SB)
MOVD $38, R11
BR callbackasm1(SB)
MOVD $39, R11
BR callbackasm1(SB)
MOVD $40, R11
BR callbackasm1(SB)
MOVD $41, R11
BR callbackasm1(SB)
MOVD $42, R11
BR callbackasm1(SB)
MOVD $43, R11
BR callbackasm1(SB)
MOVD $44, R11
BR callbackasm1(SB)
MOVD $45, R11
BR callbackasm1(SB)
MOVD $46, R11
BR callbackasm1(SB)
MOVD $47, R11
BR callbackasm1(SB)
MOVD $48, R11
BR callbackasm1(SB)
MOVD $49, R11
BR callbackasm1(SB)
MOVD $50, R11
BR callbackasm1(SB)
MOVD $51, R11
BR callbackasm1(SB)
MOVD $52, R11
BR callbackasm1(SB)
MOVD $53, R11
BR callbackasm1(SB)
MOVD $54, R11
BR callbackasm1(SB)
MOVD $55, R11
BR callbackasm1(SB)
MOVD $56, R11
BR callbackasm1(SB)
MOVD $57, R11
BR callbackasm1(SB)
MOVD $58, R11
BR callbackasm1(SB)
MOVD $59, R11
BR callbackasm1(SB)
MOVD $60, R11
BR callbackasm1(SB)
MOVD $61, R11
BR callbackasm1(SB)
MOVD $62, R11
BR callbackasm1(SB)
MOVD $63, R11
BR callbackasm1(SB)
MOVD $64, R11
BR callbackasm1(SB)
MOVD $65, R11
BR callbackasm1(SB)
MOVD $66, R11
BR callbackasm1(SB)
MOVD $67, R11
BR callbackasm1(SB)
MOVD $68, R11
BR callbackasm1(SB)
MOVD $69, R11
BR callbackasm1(SB)
MOVD $70, R11
BR callbackasm1(SB)
MOVD $71, R11
BR callbackasm1(SB)
MOVD $72, R11
BR callbackasm1(SB)
MOVD $73, R11
BR callbackasm1(SB)
MOVD $74, R11
BR callbackasm1(SB)
MOVD $75, R11
BR callbackasm1(SB)
MOVD $76, R11
BR callbackasm1(SB)
MOVD $77, R11
BR callbackasm1(SB)
MOVD $78, R11
BR callbackasm1(SB)
MOVD $79, R11
BR callbackasm1(SB)
MOVD $80, R11
BR callbackasm1(SB)
MOVD $81, R11
BR callbackasm1(SB)
MOVD $82, R11
BR callbackasm1(SB)
MOVD $83, R11
BR callbackasm1(SB)
MOVD $84, R11
BR callbackasm1(SB)
MOVD $85, R11
BR callbackasm1(SB)
MOVD $86, R11
BR callbackasm1(SB)
MOVD $87, R11
BR callbackasm1(SB)
MOVD $88, R11
BR callbackasm1(SB)
MOVD $89, R11
BR callbackasm1(SB)
MOVD $90, R11
BR callbackasm1(SB)
MOVD $91, R11
BR callbackasm1(SB)
MOVD $92, R11
BR callbackasm1(SB)
MOVD $93, R11
BR callbackasm1(SB)
MOVD $94, R11
BR callbackasm1(SB)
MOVD $95, R11
BR callbackasm1(SB)
MOVD $96, R11
BR callbackasm1(SB)
MOVD $97, R11
BR callbackasm1(SB)
MOVD $98, R11
BR callbackasm1(SB)
MOVD $99, R11
BR callbackasm1(SB)
MOVD $100, R11
BR callbackasm1(SB)
MOVD $101, R11
BR callbackasm1(SB)
MOVD $102, R11
BR callbackasm1(SB)
MOVD $103, R11
BR callbackasm1(SB)
MOVD $104, R11
BR callbackasm1(SB)
MOVD $105, R11
BR callbackasm1(SB)
MOVD $106, R11
BR callbackasm1(SB)
MOVD $107, R11
BR callbackasm1(SB)
MOVD $108, R11
BR callbackasm1(SB)
MOVD $109, R11
BR callbackasm1(SB)
MOVD $110, R11
BR callbackasm1(SB)
MOVD $111, R11
BR callbackasm1(SB)
MOVD $112, R11
BR callbackasm1(SB)
MOVD $113, R11
BR callbackasm1(SB)
MOVD $114, R11
BR callbackasm1(SB)
MOVD $115, R11
BR callbackasm1(SB)
MOVD $116, R11
BR callbackasm1(SB)
MOVD $117, R11
BR callbackasm1(SB)
MOVD $118, R11
BR callbackasm1(SB)
MOVD $119, R11
BR callbackasm1(SB)
MOVD $120, R11
BR callbackasm1(SB)
MOVD $121, R11
BR callbackasm1(SB)
MOVD $122, R11
BR callbackasm1(SB)
MOVD $123, R11
BR callbackasm1(SB)
MOVD $124, R11
BR callbackasm1(SB)
MOVD $125, R11
BR callbackasm1(SB)
MOVD $126, R11
BR callbackasm1(SB)
MOVD $127, R11
BR callbackasm1(SB)
MOVD $128, R11
BR callbackasm1(SB)
MOVD $129, R11
BR callbackasm1(SB)
MOVD $130, R11
BR callbackasm1(SB)
MOVD $131, R11
BR callbackasm1(SB)
MOVD $132, R11
BR callbackasm1(SB)
MOVD $133, R11
BR callbackasm1(SB)
MOVD $134, R11
BR callbackasm1(SB)
MOVD $135, R11
BR callbackasm1(SB)
MOVD $136, R11
BR callbackasm1(SB)
MOVD $137, R11
BR callbackasm1(SB)
MOVD $138, R11
BR callbackasm1(SB)
MOVD $139, R11
BR callbackasm1(SB)
MOVD $140, R11
BR callbackasm1(SB)
MOVD $141, R11
BR callbackasm1(SB)
MOVD $142, R11
BR callbackasm1(SB)
MOVD $143, R11
BR callbackasm1(SB)
MOVD $144, R11
BR callbackasm1(SB)
MOVD $145, R11
BR callbackasm1(SB)
MOVD $146, R11
BR callbackasm1(SB)
MOVD $147, R11
BR callbackasm1(SB)
MOVD $148, R11
BR callbackasm1(SB)
MOVD $149, R11
BR callbackasm1(SB)
MOVD $150, R11
BR callbackasm1(SB)
MOVD $151, R11
BR callbackasm1(SB)
MOVD $152, R11
BR callbackasm1(SB)
MOVD $153, R11
BR callbackasm1(SB)
MOVD $154, R11
BR callbackasm1(SB)
MOVD $155, R11
BR callbackasm1(SB)
MOVD $156, R11
BR callbackasm1(SB)
MOVD $157, R11
BR callbackasm1(SB)
MOVD $158, R11
BR callbackasm1(SB)
MOVD $159, R11
BR callbackasm1(SB)
MOVD $160, R11
BR callbackasm1(SB)
MOVD $161, R11
BR callbackasm1(SB)
MOVD $162, R11
BR callbackasm1(SB)
MOVD $163, R11
BR callbackasm1(SB)
MOVD $164, R11
BR callbackasm1(SB)
MOVD $165, R11
BR callbackasm1(SB)
MOVD $166, R11
BR callbackasm1(SB)
MOVD $167, R11
BR callbackasm1(SB)
MOVD $168, R11
BR callbackasm1(SB)
MOVD $169, R11
BR callbackasm1(SB)
MOVD $170, R11
BR callbackasm1(SB)
MOVD $171, R11
BR callbackasm1(SB)
MOVD $172, R11
BR callbackasm1(SB)
MOVD $173, R11
BR callbackasm1(SB)
MOVD $174, R11
BR callbackasm1(SB)
MOVD $175, R11
BR callbackasm1(SB)
MOVD $176, R11
BR callbackasm1(SB)
MOVD $177, R11
BR callbackasm1(SB)
MOVD $178, R11
BR callbackasm1(SB)
MOVD $179, R11
BR callbackasm1(SB)
MOVD $180, R11
BR callbackasm1(SB)
MOVD $181, R11
BR callbackasm1(SB)
MOVD $182, R11
BR callbackasm1(SB)
MOVD $183, R11
BR callbackasm1(SB)
MOVD $184, R11
BR callbackasm1(SB)
MOVD $185, R11
BR callbackasm1(SB)
MOVD $186, R11
BR callbackasm1(SB)
MOVD $187, R11
BR callbackasm1(SB)
MOVD $188, R11
BR callbackasm1(SB)
MOVD $189, R11
BR callbackasm1(SB)
MOVD $190, R11
BR callbackasm1(SB)
MOVD $191, R11
BR callbackasm1(SB)
MOVD $192, R11
BR callbackasm1(SB)
MOVD $193, R11
BR callbackasm1(SB)
MOVD $194, R11
BR callbackasm1(SB)
MOVD $195, R11
BR callbackasm1(SB)
MOVD $196, R11
BR callbackasm1(SB)
MOVD $197, R11
BR callbackasm1(SB)
MOVD $198, R11
BR callbackasm1(SB)
MOVD $199, R11
BR callbackasm1(SB)
MOVD $200, R11
BR callbackasm1(SB)
MOVD $201, R11
BR callbackasm1(SB)
MOVD $202, R11
BR callbackasm1(SB)
MOVD $203, R11
BR callbackasm1(SB)
MOVD $204, R11
BR callbackasm1(SB)
MOVD $205, R11
BR callbackasm1(SB)
MOVD $206, R11
BR callbackasm1(SB)
MOVD $207, R11
BR callbackasm1(SB)
MOVD $208, R11
BR callbackasm1(SB)
MOVD $209, R11
BR callbackasm1(SB)
MOVD $210, R11
BR callbackasm1(SB)
MOVD $211, R11
BR callbackasm1(SB)
MOVD $212, R11
BR callbackasm1(SB)
MOVD $213, R11
BR callbackasm1(SB)
MOVD $214, R11
BR callbackasm1(SB)
MOVD $215, R11
BR callbackasm1(SB)
MOVD $216, R11
BR callbackasm1(SB)
MOVD $217, R11
BR callbackasm1(SB)
MOVD $218, R11
BR callbackasm1(SB)
MOVD $219, R11
BR callbackasm1(SB)
MOVD $220, R11
BR callbackasm1(SB)
MOVD $221, R11
BR callbackasm1(SB)
MOVD $222, R11
BR callbackasm1(SB)
MOVD $223, R11
BR callbackasm1(SB)
MOVD $224, R11
BR callbackasm1(SB)
MOVD $225, R11
BR callbackasm1(SB)
MOVD $226, R11
BR callbackasm1(SB)
MOVD $227, R11
BR callbackasm1(SB)
MOVD $228, R11
BR callbackasm1(SB)
MOVD $229, R11
BR callbackasm1(SB)
MOVD $230, R11
BR callbackasm1(SB)
MOVD $231, R11
BR callbackasm1(SB)
MOVD $232, R11
BR callbackasm1(SB)
MOVD $233, R11
BR callbackasm1(SB)
MOVD $234, R11
BR callbackasm1(SB)
MOVD $235, R11
BR callbackasm1(SB)
MOVD $236, R11
BR callbackasm1(SB)
MOVD $237, R11
BR callbackasm1(SB)
MOVD $238, R11
BR callbackasm1(SB)
MOVD $239, R11
BR callbackasm1(SB)
MOVD $240, R11
BR callbackasm1(SB)
MOVD $241, R11
BR callbackasm1(SB)
MOVD $242, R11
BR callbackasm1(SB)
MOVD $243, R11
BR callbackasm1(SB)
MOVD $244, R11
BR callbackasm1(SB)
MOVD $245, R11
BR callbackasm1(SB)
MOVD $246, R11
BR callbackasm1(SB)
MOVD $247, R11
BR callbackasm1(SB)
MOVD $248, R11
BR callbackasm1(SB)
MOVD $249, R11
BR callbackasm1(SB)
MOVD $250, R11
BR callbackasm1(SB)
MOVD $251, R11
BR callbackasm1(SB)
MOVD $252, R11
BR callbackasm1(SB)
MOVD $253, R11
BR callbackasm1(SB)
MOVD $254, R11
BR callbackasm1(SB)
MOVD $255, R11
BR callbackasm1(SB)
MOVD $256, R11
BR callbackasm1(SB)
MOVD $257, R11
BR callbackasm1(SB)
MOVD $258, R11
BR callbackasm1(SB)
MOVD $259, R11
BR callbackasm1(SB)
MOVD $260, R11
BR callbackasm1(SB)
MOVD $261, R11
BR callbackasm1(SB)
MOVD $262, R11
BR callbackasm1(SB)
MOVD $263, R11
BR callbackasm1(SB)
MOVD $264, R11
BR callbackasm1(SB)
MOVD $265, R11
BR callbackasm1(SB)
MOVD $266, R11
BR callbackasm1(SB)
MOVD $267, R11
BR callbackasm1(SB)
MOVD $268, R11
BR callbackasm1(SB)
MOVD $269, R11
BR callbackasm1(SB)
MOVD $270, R11
BR callbackasm1(SB)
MOVD $271, R11
BR callbackasm1(SB)
MOVD $272, R11
BR callbackasm1(SB)
MOVD $273, R11
BR callbackasm1(SB)
MOVD $274, R11
BR callbackasm1(SB)
MOVD $275, R11
BR callbackasm1(SB)
MOVD $276, R11
BR callbackasm1(SB)
MOVD $277, R11
BR callbackasm1(SB)
MOVD $278, R11
BR callbackasm1(SB)
MOVD $279, R11
BR callbackasm1(SB)
MOVD $280, R11
BR callbackasm1(SB)
MOVD $281, R11
BR callbackasm1(SB)
MOVD $282, R11
BR callbackasm1(SB)
MOVD $283, R11
BR callbackasm1(SB)
MOVD $284, R11
BR callbackasm1(SB)
MOVD $285, R11
BR callbackasm1(SB)
MOVD $286, R11
BR callbackasm1(SB)
MOVD $287, R11
BR callbackasm1(SB)
MOVD $288, R11
BR callbackasm1(SB)
MOVD $289, R11
BR callbackasm1(SB)
MOVD $290, R11
BR callbackasm1(SB)
MOVD $291, R11
BR callbackasm1(SB)
MOVD $292, R11
BR callbackasm1(SB)
MOVD $293, R11
BR callbackasm1(SB)
MOVD $294, R11
BR callbackasm1(SB)
MOVD $295, R11
BR callbackasm1(SB)
MOVD $296, R11
BR callbackasm1(SB)
MOVD $297, R11
BR callbackasm1(SB)
MOVD $298, R11
BR callbackasm1(SB)
MOVD $299, R11
BR callbackasm1(SB)
MOVD $300, R11
BR callbackasm1(SB)
MOVD $301, R11
BR callbackasm1(SB)
MOVD $302, R11
BR callbackasm1(SB)
MOVD $303, R11
BR callbackasm1(SB)
MOVD $304, R11
BR callbackasm1(SB)
MOVD $305, R11
BR callbackasm1(SB)
MOVD $306, R11
BR callbackasm1(SB)
MOVD $307, R11
BR callbackasm1(SB)
MOVD $308, R11
BR callbackasm1(SB)
MOVD $309, R11
BR callbackasm1(SB)
MOVD $310, R11
BR callbackasm1(SB)
MOVD $311, R11
BR callbackasm1(SB)
MOVD $312, R11
BR callbackasm1(SB)
MOVD $313, R11
BR callbackasm1(SB)
MOVD $314, R11
BR callbackasm1(SB)
MOVD $315, R11
BR callbackasm1(SB)
MOVD $316, R11
BR callbackasm1(SB)
MOVD $317, R11
BR callbackasm1(SB)
MOVD $318, R11
BR callbackasm1(SB)
MOVD $319, R11
BR callbackasm1(SB)
MOVD $320, R11
BR callbackasm1(SB)
MOVD $321, R11
BR callbackasm1(SB)
MOVD $322, R11
BR callbackasm1(SB)
MOVD $323, R11
BR callbackasm1(SB)
MOVD $324, R11
BR callbackasm1(SB)
MOVD $325, R11
BR callbackasm1(SB)
MOVD $326, R11
BR callbackasm1(SB)
MOVD $327, R11
BR callbackasm1(SB)
MOVD $328, R11
BR callbackasm1(SB)
MOVD $329, R11
BR callbackasm1(SB)
MOVD $330, R11
BR callbackasm1(SB)
MOVD $331, R11
BR callbackasm1(SB)
MOVD $332, R11
BR callbackasm1(SB)
MOVD $333, R11
BR callbackasm1(SB)
MOVD $334, R11
BR callbackasm1(SB)
MOVD $335, R11
BR callbackasm1(SB)
MOVD $336, R11
BR callbackasm1(SB)
MOVD $337, R11
BR callbackasm1(SB)
MOVD $338, R11
BR callbackasm1(SB)
MOVD $339, R11
BR callbackasm1(SB)
MOVD $340, R11
BR callbackasm1(SB)
MOVD $341, R11
BR callbackasm1(SB)
MOVD $342, R11
BR callbackasm1(SB)
MOVD $343, R11
BR callbackasm1(SB)
MOVD $344, R11
BR callbackasm1(SB)
MOVD $345, R11
BR callbackasm1(SB)
MOVD $346, R11
BR callbackasm1(SB)
MOVD $347, R11
BR callbackasm1(SB)
MOVD $348, R11
BR callbackasm1(SB)
MOVD $349, R11
BR callbackasm1(SB)
MOVD $350, R11
BR callbackasm1(SB)
MOVD $351, R11
BR callbackasm1(SB)
MOVD $352, R11
BR callbackasm1(SB)
MOVD $353, R11
BR callbackasm1(SB)
MOVD $354, R11
BR callbackasm1(SB)
MOVD $355, R11
BR callbackasm1(SB)
MOVD $356, R11
BR callbackasm1(SB)
MOVD $357, R11
BR callbackasm1(SB)
MOVD $358, R11
BR callbackasm1(SB)
MOVD $359, R11
BR callbackasm1(SB)
MOVD $360, R11
BR callbackasm1(SB)
MOVD $361, R11
BR callbackasm1(SB)
MOVD $362, R11
BR callbackasm1(SB)
MOVD $363, R11
BR callbackasm1(SB)
MOVD $364, R11
BR callbackasm1(SB)
MOVD $365, R11
BR callbackasm1(SB)
MOVD $366, R11
BR callbackasm1(SB)
MOVD $367, R11
BR callbackasm1(SB)
MOVD $368, R11
BR callbackasm1(SB)
MOVD $369, R11
BR callbackasm1(SB)
MOVD $370, R11
BR callbackasm1(SB)
MOVD $371, R11
BR callbackasm1(SB)
MOVD $372, R11
BR callbackasm1(SB)
MOVD $373, R11
BR callbackasm1(SB)
MOVD $374, R11
BR callbackasm1(SB)
MOVD $375, R11
BR callbackasm1(SB)
MOVD $376, R11
BR callbackasm1(SB)
MOVD $377, R11
BR callbackasm1(SB)
MOVD $378, R11
BR callbackasm1(SB)
MOVD $379, R11
BR callbackasm1(SB)
MOVD $380, R11
BR callbackasm1(SB)
MOVD $381, R11
BR callbackasm1(SB)
MOVD $382, R11
BR callbackasm1(SB)
MOVD $383, R11
BR callbackasm1(SB)
MOVD $384, R11
BR callbackasm1(SB)
MOVD $385, R11
BR callbackasm1(SB)
MOVD $386, R11
BR callbackasm1(SB)
MOVD $387, R11
BR callbackasm1(SB)
MOVD $388, R11
BR callbackasm1(SB)
MOVD $389, R11
BR callbackasm1(SB)
MOVD $390, R11
BR callbackasm1(SB)
MOVD $391, R11
BR callbackasm1(SB)
MOVD $392, R11
BR callbackasm1(SB)
MOVD $393, R11
BR callbackasm1(SB)
MOVD $394, R11
BR callbackasm1(SB)
MOVD $395, R11
BR callbackasm1(SB)
MOVD $396, R11
BR callbackasm1(SB)
MOVD $397, R11
BR callbackasm1(SB)
MOVD $398, R11
BR callbackasm1(SB)
MOVD $399, R11
BR callbackasm1(SB)
MOVD $400, R11
BR callbackasm1(SB)
MOVD $401, R11
BR callbackasm1(SB)
MOVD $402, R11
BR callbackasm1(SB)
MOVD $403, R11
BR callbackasm1(SB)
MOVD $404, R11
BR callbackasm1(SB)
MOVD $405, R11
BR callbackasm1(SB)
MOVD $406, R11
BR callbackasm1(SB)
MOVD $407, R11
BR callbackasm1(SB)
MOVD $408, R11
BR callbackasm1(SB)
MOVD $409, R11
BR callbackasm1(SB)
MOVD $410, R11
BR callbackasm1(SB)
MOVD $411, R11
BR callbackasm1(SB)
MOVD $412, R11
BR callbackasm1(SB)
MOVD $413, R11
BR callbackasm1(SB)
MOVD $414, R11
BR callbackasm1(SB)
MOVD $415, R11
BR callbackasm1(SB)
MOVD $416, R11
BR callbackasm1(SB)
MOVD $417, R11
BR callbackasm1(SB)
MOVD $418, R11
BR callbackasm1(SB)
MOVD $419, R11
BR callbackasm1(SB)
MOVD $420, R11
BR callbackasm1(SB)
MOVD $421, R11
BR callbackasm1(SB)
MOVD $422, R11
BR callbackasm1(SB)
MOVD $423, R11
BR callbackasm1(SB)
MOVD $424, R11
BR callbackasm1(SB)
MOVD $425, R11
BR callbackasm1(SB)
MOVD $426, R11
BR callbackasm1(SB)
MOVD $427, R11
BR callbackasm1(SB)
MOVD $428, R11
BR callbackasm1(SB)
MOVD $429, R11
BR callbackasm1(SB)
MOVD $430, R11
BR callbackasm1(SB)
MOVD $431, R11
BR callbackasm1(SB)
MOVD $432, R11
BR callbackasm1(SB)
MOVD $433, R11
BR callbackasm1(SB)
MOVD $434, R11
BR callbackasm1(SB)
MOVD $435, R11
BR callbackasm1(SB)
MOVD $436, R11
BR callbackasm1(SB)
MOVD $437, R11
BR callbackasm1(SB)
MOVD $438, R11
BR callbackasm1(SB)
MOVD $439, R11
BR callbackasm1(SB)
MOVD $440, R11
BR callbackasm1(SB)
MOVD $441, R11
BR callbackasm1(SB)
MOVD $442, R11
BR callbackasm1(SB)
MOVD $443, R11
BR callbackasm1(SB)
MOVD $444, R11
BR callbackasm1(SB)
MOVD $445, R11
BR callbackasm1(SB)
MOVD $446, R11
BR callbackasm1(SB)
MOVD $447, R11
BR callbackasm1(SB)
MOVD $448, R11
BR callbackasm1(SB)
MOVD $449, R11
BR callbackasm1(SB)
MOVD $450, R11
BR callbackasm1(SB)
MOVD $451, R11
BR callbackasm1(SB)
MOVD $452, R11
BR callbackasm1(SB)
MOVD $453, R11
BR callbackasm1(SB)
MOVD $454, R11
BR callbackasm1(SB)
MOVD $455, R11
BR callbackasm1(SB)
MOVD $456, R11
BR callbackasm1(SB)
MOVD $457, R11
BR callbackasm1(SB)
MOVD $458, R11
BR callbackasm1(SB)
MOVD $459, R11
BR callbackasm1(SB)
MOVD $460, R11
BR callbackasm1(SB)
MOVD $461, R11
BR callbackasm1(SB)
MOVD $462, R11
BR callbackasm1(SB)
MOVD $463, R11
BR callbackasm1(SB)
MOVD $464, R11
BR callbackasm1(SB)
MOVD $465, R11
BR callbackasm1(SB)
MOVD $466, R11
BR callbackasm1(SB)
MOVD $467, R11
BR callbackasm1(SB)
MOVD $468, R11
BR callbackasm1(SB)
MOVD $469, R11
BR callbackasm1(SB)
MOVD $470, R11
BR callbackasm1(SB)
MOVD $471, R11
BR callbackasm1(SB)
MOVD $472, R11
BR callbackasm1(SB)
MOVD $473, R11
BR callbackasm1(SB)
MOVD $474, R11
BR callbackasm1(SB)
MOVD $475, R11
BR callbackasm1(SB)
MOVD $476, R11
BR callbackasm1(SB)
MOVD $477, R11
BR callbackasm1(SB)
MOVD $478, R11
BR callbackasm1(SB)
MOVD $479, R11
BR callbackasm1(SB)
MOVD $480, R11
BR callbackasm1(SB)
MOVD $481, R11
BR callbackasm1(SB)
MOVD $482, R11
BR callbackasm1(SB)
MOVD $483, R11
BR callbackasm1(SB)
MOVD $484, R11
BR callbackasm1(SB)
MOVD $485, R11
BR callbackasm1(SB)
MOVD $486, R11
BR callbackasm1(SB)
MOVD $487, R11
BR callbackasm1(SB)
MOVD $488, R11
BR callbackasm1(SB)
MOVD $489, R11
BR callbackasm1(SB)
MOVD $490, R11
BR callbackasm1(SB)
MOVD $491, R11
BR callbackasm1(SB)
MOVD $492, R11
BR callbackasm1(SB)
MOVD $493, R11
BR callbackasm1(SB)
MOVD $494, R11
BR callbackasm1(SB)
MOVD $495, R11
BR callbackasm1(SB)
MOVD $496, R11
BR callbackasm1(SB)
MOVD $497, R11
BR callbackasm1(SB)
MOVD $498, R11
BR callbackasm1(SB)
MOVD $499, R11
BR callbackasm1(SB)
MOVD $500, R11
BR callbackasm1(SB)
MOVD $501, R11
BR callbackasm1(SB)
MOVD $502, R11
BR callbackasm1(SB)
MOVD $503, R11
BR callbackasm1(SB)
MOVD $504, R11
BR callbackasm1(SB)
MOVD $505, R11
BR callbackasm1(SB)
MOVD $506, R11
BR callbackasm1(SB)
MOVD $507, R11
BR callbackasm1(SB)
MOVD $508, R11
BR callbackasm1(SB)
MOVD $509, R11
BR callbackasm1(SB)
MOVD $510, R11
BR callbackasm1(SB)
MOVD $511, R11
BR callbackasm1(SB)
MOVD $512, R11
BR callbackasm1(SB)
MOVD $513, R11
BR callbackasm1(SB)
MOVD $514, R11
BR callbackasm1(SB)
MOVD $515, R11
BR callbackasm1(SB)
MOVD $516, R11
BR callbackasm1(SB)
MOVD $517, R11
BR callbackasm1(SB)
MOVD $518, R11
BR callbackasm1(SB)
MOVD $519, R11
BR callbackasm1(SB)
MOVD $520, R11
BR callbackasm1(SB)
MOVD $521, R11
BR callbackasm1(SB)
MOVD $522, R11
BR callbackasm1(SB)
MOVD $523, R11
BR callbackasm1(SB)
MOVD $524, R11
BR callbackasm1(SB)
MOVD $525, R11
BR callbackasm1(SB)
MOVD $526, R11
BR callbackasm1(SB)
MOVD $527, R11
BR callbackasm1(SB)
MOVD $528, R11
BR callbackasm1(SB)
MOVD $529, R11
BR callbackasm1(SB)
MOVD $530, R11
BR callbackasm1(SB)
MOVD $531, R11
BR callbackasm1(SB)
MOVD $532, R11
BR callbackasm1(SB)
MOVD $533, R11
BR callbackasm1(SB)
MOVD $534, R11
BR callbackasm1(SB)
MOVD $535, R11
BR callbackasm1(SB)
MOVD $536, R11
BR callbackasm1(SB)
MOVD $537, R11
BR callbackasm1(SB)
MOVD $538, R11
BR callbackasm1(SB)
MOVD $539, R11
BR callbackasm1(SB)
MOVD $540, R11
BR callbackasm1(SB)
MOVD $541, R11
BR callbackasm1(SB)
MOVD $542, R11
BR callbackasm1(SB)
MOVD $543, R11
BR callbackasm1(SB)
MOVD $544, R11
BR callbackasm1(SB)
MOVD $545, R11
BR callbackasm1(SB)
MOVD $546, R11
BR callbackasm1(SB)
MOVD $547, R11
BR callbackasm1(SB)
MOVD $548, R11
BR callbackasm1(SB)
MOVD $549, R11
BR callbackasm1(SB)
MOVD $550, R11
BR callbackasm1(SB)
MOVD $551, R11
BR callbackasm1(SB)
MOVD $552, R11
BR callbackasm1(SB)
MOVD $553, R11
BR callbackasm1(SB)
MOVD $554, R11
BR callbackasm1(SB)
MOVD $555, R11
BR callbackasm1(SB)
MOVD $556, R11
BR callbackasm1(SB)
MOVD $557, R11
BR callbackasm1(SB)
MOVD $558, R11
BR callbackasm1(SB)
MOVD $559, R11
BR callbackasm1(SB)
MOVD $560, R11
BR callbackasm1(SB)
MOVD $561, R11
BR callbackasm1(SB)
MOVD $562, R11
BR callbackasm1(SB)
MOVD $563, R11
BR callbackasm1(SB)
MOVD $564, R11
BR callbackasm1(SB)
MOVD $565, R11
BR callbackasm1(SB)
MOVD $566, R11
BR callbackasm1(SB)
MOVD $567, R11
BR callbackasm1(SB)
MOVD $568, R11
BR callbackasm1(SB)
MOVD $569, R11
BR callbackasm1(SB)
MOVD $570, R11
BR callbackasm1(SB)
MOVD $571, R11
BR callbackasm1(SB)
MOVD $572, R11
BR callbackasm1(SB)
MOVD $573, R11
BR callbackasm1(SB)
MOVD $574, R11
BR callbackasm1(SB)
MOVD $575, R11
BR callbackasm1(SB)
MOVD $576, R11
BR callbackasm1(SB)
MOVD $577, R11
BR callbackasm1(SB)
MOVD $578, R11
BR callbackasm1(SB)
MOVD $579, R11
BR callbackasm1(SB)
MOVD $580, R11
BR callbackasm1(SB)
MOVD $581, R11
BR callbackasm1(SB)
MOVD $582, R11
BR callbackasm1(SB)
MOVD $583, R11
BR callbackasm1(SB)
MOVD $584, R11
BR callbackasm1(SB)
MOVD $585, R11
BR callbackasm1(SB)
MOVD $586, R11
BR callbackasm1(SB)
MOVD $587, R11
BR callbackasm1(SB)
MOVD $588, R11
BR callbackasm1(SB)
MOVD $589, R11
BR callbackasm1(SB)
MOVD $590, R11
BR callbackasm1(SB)
MOVD $591, R11
BR callbackasm1(SB)
MOVD $592, R11
BR callbackasm1(SB)
MOVD $593, R11
BR callbackasm1(SB)
MOVD $594, R11
BR callbackasm1(SB)
MOVD $595, R11
BR callbackasm1(SB)
MOVD $596, R11
BR callbackasm1(SB)
MOVD $597, R11
BR callbackasm1(SB)
MOVD $598, R11
BR callbackasm1(SB)
MOVD $599, R11
BR callbackasm1(SB)
MOVD $600, R11
BR callbackasm1(SB)
MOVD $601, R11
BR callbackasm1(SB)
MOVD $602, R11
BR callbackasm1(SB)
MOVD $603, R11
BR callbackasm1(SB)
MOVD $604, R11
BR callbackasm1(SB)
MOVD $605, R11
BR callbackasm1(SB)
MOVD $606, R11
BR callbackasm1(SB)
MOVD $607, R11
BR callbackasm1(SB)
MOVD $608, R11
BR callbackasm1(SB)
MOVD $609, R11
BR callbackasm1(SB)
MOVD $610, R11
BR callbackasm1(SB)
MOVD $611, R11
BR callbackasm1(SB)
MOVD $612, R11
BR callbackasm1(SB)
MOVD $613, R11
BR callbackasm1(SB)
MOVD $614, R11
BR callbackasm1(SB)
MOVD $615, R11
BR callbackasm1(SB)
MOVD $616, R11
BR callbackasm1(SB)
MOVD $617, R11
BR callbackasm1(SB)
MOVD $618, R11
BR callbackasm1(SB)
MOVD $619, R11
BR callbackasm1(SB)
MOVD $620, R11
BR callbackasm1(SB)
MOVD $621, R11
BR callbackasm1(SB)
MOVD $622, R11
BR callbackasm1(SB)
MOVD $623, R11
BR callbackasm1(SB)
MOVD $624, R11
BR callbackasm1(SB)
MOVD $625, R11
BR callbackasm1(SB)
MOVD $626, R11
BR callbackasm1(SB)
MOVD $627, R11
BR callbackasm1(SB)
MOVD $628, R11
BR callbackasm1(SB)
MOVD $629, R11
BR callbackasm1(SB)
MOVD $630, R11
BR callbackasm1(SB)
MOVD $631, R11
BR callbackasm1(SB)
MOVD $632, R11
BR callbackasm1(SB)
MOVD $633, R11
BR callbackasm1(SB)
MOVD $634, R11
BR callbackasm1(SB)
MOVD $635, R11
BR callbackasm1(SB)
MOVD $636, R11
BR callbackasm1(SB)
MOVD $637, R11
BR callbackasm1(SB)
MOVD $638, R11
BR callbackasm1(SB)
MOVD $639, R11
BR callbackasm1(SB)
MOVD $640, R11
BR callbackasm1(SB)
MOVD $641, R11
BR callbackasm1(SB)
MOVD $642, R11
BR callbackasm1(SB)
MOVD $643, R11
BR callbackasm1(SB)
MOVD $644, R11
BR callbackasm1(SB)
MOVD $645, R11
BR callbackasm1(SB)
MOVD $646, R11
BR callbackasm1(SB)
MOVD $647, R11
BR callbackasm1(SB)
MOVD $648, R11
BR callbackasm1(SB)
MOVD $649, R11
BR callbackasm1(SB)
MOVD $650, R11
BR callbackasm1(SB)
MOVD $651, R11
BR callbackasm1(SB)
MOVD $652, R11
BR callbackasm1(SB)
MOVD $653, R11
BR callbackasm1(SB)
MOVD $654, R11
BR callbackasm1(SB)
MOVD $655, R11
BR callbackasm1(SB)
MOVD $656, R11
BR callbackasm1(SB)
MOVD $657, R11
BR callbackasm1(SB)
MOVD $658, R11
BR callbackasm1(SB)
MOVD $659, R11
BR callbackasm1(SB)
MOVD $660, R11
BR callbackasm1(SB)
MOVD $661, R11
BR callbackasm1(SB)
MOVD $662, R11
BR callbackasm1(SB)
MOVD $663, R11
BR callbackasm1(SB)
MOVD $664, R11
BR callbackasm1(SB)
MOVD $665, R11
BR callbackasm1(SB)
MOVD $666, R11
BR callbackasm1(SB)
MOVD $667, R11
BR callbackasm1(SB)
MOVD $668, R11
BR callbackasm1(SB)
MOVD $669, R11
BR callbackasm1(SB)
MOVD $670, R11
BR callbackasm1(SB)
MOVD $671, R11
BR callbackasm1(SB)
MOVD $672, R11
BR callbackasm1(SB)
MOVD $673, R11
BR callbackasm1(SB)
MOVD $674, R11
BR callbackasm1(SB)
MOVD $675, R11
BR callbackasm1(SB)
MOVD $676, R11
BR callbackasm1(SB)
MOVD $677, R11
BR callbackasm1(SB)
MOVD $678, R11
BR callbackasm1(SB)
MOVD $679, R11
BR callbackasm1(SB)
MOVD $680, R11
BR callbackasm1(SB)
MOVD $681, R11
BR callbackasm1(SB)
MOVD $682, R11
BR callbackasm1(SB)
MOVD $683, R11
BR callbackasm1(SB)
MOVD $684, R11
BR callbackasm1(SB)
MOVD $685, R11
BR callbackasm1(SB)
MOVD $686, R11
BR callbackasm1(SB)
MOVD $687, R11
BR callbackasm1(SB)
MOVD $688, R11
BR callbackasm1(SB)
MOVD $689, R11
BR callbackasm1(SB)
MOVD $690, R11
BR callbackasm1(SB)
MOVD $691, R11
BR callbackasm1(SB)
MOVD $692, R11
BR callbackasm1(SB)
MOVD $693, R11
BR callbackasm1(SB)
MOVD $694, R11
BR callbackasm1(SB)
MOVD $695, R11
BR callbackasm1(SB)
MOVD $696, R11
BR callbackasm1(SB)
MOVD $697, R11
BR callbackasm1(SB)
MOVD $698, R11
BR callbackasm1(SB)
MOVD $699, R11
BR callbackasm1(SB)
MOVD $700, R11
BR callbackasm1(SB)
MOVD $701, R11
BR callbackasm1(SB)
MOVD $702, R11
BR callbackasm1(SB)
MOVD $703, R11
BR callbackasm1(SB)
MOVD $704, R11
BR callbackasm1(SB)
MOVD $705, R11
BR callbackasm1(SB)
MOVD $706, R11
BR callbackasm1(SB)
MOVD $707, R11
BR callbackasm1(SB)
MOVD $708, R11
BR callbackasm1(SB)
MOVD $709, R11
BR callbackasm1(SB)
MOVD $710, R11
BR callbackasm1(SB)
MOVD $711, R11
BR callbackasm1(SB)
MOVD $712, R11
BR callbackasm1(SB)
MOVD $713, R11
BR callbackasm1(SB)
MOVD $714, R11
BR callbackasm1(SB)
MOVD $715, R11
BR callbackasm1(SB)
MOVD $716, R11
BR callbackasm1(SB)
MOVD $717, R11
BR callbackasm1(SB)
MOVD $718, R11
BR callbackasm1(SB)
MOVD $719, R11
BR callbackasm1(SB)
MOVD $720, R11
BR callbackasm1(SB)
MOVD $721, R11
BR callbackasm1(SB)
MOVD $722, R11
BR callbackasm1(SB)
MOVD $723, R11
BR callbackasm1(SB)
MOVD $724, R11
BR callbackasm1(SB)
MOVD $725, R11
BR callbackasm1(SB)
MOVD $726, R11
BR callbackasm1(SB)
MOVD $727, R11
BR callbackasm1(SB)
MOVD $728, R11
BR callbackasm1(SB)
MOVD $729, R11
BR callbackasm1(SB)
MOVD $730, R11
BR callbackasm1(SB)
MOVD $731, R11
BR callbackasm1(SB)
MOVD $732, R11
BR callbackasm1(SB)
MOVD $733, R11
BR callbackasm1(SB)
MOVD $734, R11
BR callbackasm1(SB)
MOVD $735, R11
BR callbackasm1(SB)
MOVD $736, R11
BR callbackasm1(SB)
MOVD $737, R11
BR callbackasm1(SB)
MOVD $738, R11
BR callbackasm1(SB)
MOVD $739, R11
BR callbackasm1(SB)
MOVD $740, R11
BR callbackasm1(SB)
MOVD $741, R11
BR callbackasm1(SB)
MOVD $742, R11
BR callbackasm1(SB)
MOVD $743, R11
BR callbackasm1(SB)
MOVD $744, R11
BR callbackasm1(SB)
MOVD $745, R11
BR callbackasm1(SB)
MOVD $746, R11
BR callbackasm1(SB)
MOVD $747, R11
BR callbackasm1(SB)
MOVD $748, R11
BR callbackasm1(SB)
MOVD $749, R11
BR callbackasm1(SB)
MOVD $750, R11
BR callbackasm1(SB)
MOVD $751, R11
BR callbackasm1(SB)
MOVD $752, R11
BR callbackasm1(SB)
MOVD $753, R11
BR callbackasm1(SB)
MOVD $754, R11
BR callbackasm1(SB)
MOVD $755, R11
BR callbackasm1(SB)
MOVD $756, R11
BR callbackasm1(SB)
MOVD $757, R11
BR callbackasm1(SB)
MOVD $758, R11
BR callbackasm1(SB)
MOVD $759, R11
BR callbackasm1(SB)
MOVD $760, R11
BR callbackasm1(SB)
MOVD $761, R11
BR callbackasm1(SB)
MOVD $762, R11
BR callbackasm1(SB)
MOVD $763, R11
BR callbackasm1(SB)
MOVD $764, R11
BR callbackasm1(SB)
MOVD $765, R11
BR callbackasm1(SB)
MOVD $766, R11
BR callbackasm1(SB)
MOVD $767, R11
BR callbackasm1(SB)
MOVD $768, R11
BR callbackasm1(SB)
MOVD $769, R11
BR callbackasm1(SB)
MOVD $770, R11
BR callbackasm1(SB)
MOVD $771, R11
BR callbackasm1(SB)
MOVD $772, R11
BR callbackasm1(SB)
MOVD $773, R11
BR callbackasm1(SB)
MOVD $774, R11
BR callbackasm1(SB)
MOVD $775, R11
BR callbackasm1(SB)
MOVD $776, R11
BR callbackasm1(SB)
MOVD $777, R11
BR callbackasm1(SB)
MOVD $778, R11
BR callbackasm1(SB)
MOVD $779, R11
BR callbackasm1(SB)
MOVD $780, R11
BR callbackasm1(SB)
MOVD $781, R11
BR callbackasm1(SB)
MOVD $782, R11
BR callbackasm1(SB)
MOVD $783, R11
BR callbackasm1(SB)
MOVD $784, R11
BR callbackasm1(SB)
MOVD $785, R11
BR callbackasm1(SB)
MOVD $786, R11
BR callbackasm1(SB)
MOVD $787, R11
BR callbackasm1(SB)
MOVD $788, R11
BR callbackasm1(SB)
MOVD $789, R11
BR callbackasm1(SB)
MOVD $790, R11
BR callbackasm1(SB)
MOVD $791, R11
BR callbackasm1(SB)
MOVD $792, R11
BR callbackasm1(SB)
MOVD $793, R11
BR callbackasm1(SB)
MOVD $794, R11
BR callbackasm1(SB)
MOVD $795, R11
BR callbackasm1(SB)
MOVD $796, R11
BR callbackasm1(SB)
MOVD $797, R11
BR callbackasm1(SB)
MOVD $798, R11
BR callbackasm1(SB)
MOVD $799, R11
BR callbackasm1(SB)
MOVD $800, R11
BR callbackasm1(SB)
MOVD $801, R11
BR callbackasm1(SB)
MOVD $802, R11
BR callbackasm1(SB)
MOVD $803, R11
BR callbackasm1(SB)
MOVD $804, R11
BR callbackasm1(SB)
MOVD $805, R11
BR callbackasm1(SB)
MOVD $806, R11
BR callbackasm1(SB)
MOVD $807, R11
BR callbackasm1(SB)
MOVD $808, R11
BR callbackasm1(SB)
MOVD $809, R11
BR callbackasm1(SB)
MOVD $810, R11
BR callbackasm1(SB)
MOVD $811, R11
BR callbackasm1(SB)
MOVD $812, R11
BR callbackasm1(SB)
MOVD $813, R11
BR callbackasm1(SB)
MOVD $814, R11
BR callbackasm1(SB)
MOVD $815, R11
BR callbackasm1(SB)
MOVD $816, R11
BR callbackasm1(SB)
MOVD $817, R11
BR callbackasm1(SB)
MOVD $818, R11
BR callbackasm1(SB)
MOVD $819, R11
BR callbackasm1(SB)
MOVD $820, R11
BR callbackasm1(SB)
MOVD $821, R11
BR callbackasm1(SB)
MOVD $822, R11
BR callbackasm1(SB)
MOVD $823, R11
BR callbackasm1(SB)
MOVD $824, R11
BR callbackasm1(SB)
MOVD $825, R11
BR callbackasm1(SB)
MOVD $826, R11
BR callbackasm1(SB)
MOVD $827, R11
BR callbackasm1(SB)
MOVD $828, R11
BR callbackasm1(SB)
MOVD $829, R11
BR callbackasm1(SB)
MOVD $830, R11
BR callbackasm1(SB)
MOVD $831, R11
BR callbackasm1(SB)
MOVD $832, R11
BR callbackasm1(SB)
MOVD $833, R11
BR callbackasm1(SB)
MOVD $834, R11
BR callbackasm1(SB)
MOVD $835, R11
BR callbackasm1(SB)
MOVD $836, R11
BR callbackasm1(SB)
MOVD $837, R11
BR callbackasm1(SB)
MOVD $838, R11
BR callbackasm1(SB)
MOVD $839, R11
BR callbackasm1(SB)
MOVD $840, R11
BR callbackasm1(SB)
MOVD $841, R11
BR callbackasm1(SB)
MOVD $842, R11
BR callbackasm1(SB)
MOVD $843, R11
BR callbackasm1(SB)
MOVD $844, R11
BR callbackasm1(SB)
MOVD $845, R11
BR callbackasm1(SB)
MOVD $846, R11
BR callbackasm1(SB)
MOVD $847, R11
BR callbackasm1(SB)
MOVD $848, R11
BR callbackasm1(SB)
MOVD $849, R11
BR callbackasm1(SB)
MOVD $850, R11
BR callbackasm1(SB)
MOVD $851, R11
BR callbackasm1(SB)
MOVD $852, R11
BR callbackasm1(SB)
MOVD $853, R11
BR callbackasm1(SB)
MOVD $854, R11
BR callbackasm1(SB)
MOVD $855, R11
BR callbackasm1(SB)
MOVD $856, R11
BR callbackasm1(SB)
MOVD $857, R11
BR callbackasm1(SB)
MOVD $858, R11
BR callbackasm1(SB)
MOVD $859, R11
BR callbackasm1(SB)
MOVD $860, R11
BR callbackasm1(SB)
MOVD $861, R11
BR callbackasm1(SB)
MOVD $862, R11
BR callbackasm1(SB)
MOVD $863, R11
BR callbackasm1(SB)
MOVD $864, R11
BR callbackasm1(SB)
MOVD $865, R11
BR callbackasm1(SB)
MOVD $866, R11
BR callbackasm1(SB)
MOVD $867, R11
BR callbackasm1(SB)
MOVD $868, R11
BR callbackasm1(SB)
MOVD $869, R11
BR callbackasm1(SB)
MOVD $870, R11
BR callbackasm1(SB)
MOVD $871, R11
BR callbackasm1(SB)
MOVD $872, R11
BR callbackasm1(SB)
MOVD $873, R11
BR callbackasm1(SB)
MOVD $874, R11
BR callbackasm1(SB)
MOVD $875, R11
BR callbackasm1(SB)
MOVD $876, R11
BR callbackasm1(SB)
MOVD $877, R11
BR callbackasm1(SB)
MOVD $878, R11
BR callbackasm1(SB)
MOVD $879, R11
BR callbackasm1(SB)
MOVD $880, R11
BR callbackasm1(SB)
MOVD $881, R11
BR callbackasm1(SB)
MOVD $882, R11
BR callbackasm1(SB)
MOVD $883, R11
BR callbackasm1(SB)
MOVD $884, R11
BR callbackasm1(SB)
MOVD $885, R11
BR callbackasm1(SB)
MOVD $886, R11
BR callbackasm1(SB)
MOVD $887, R11
BR callbackasm1(SB)
MOVD $888, R11
BR callbackasm1(SB)
MOVD $889, R11
BR callbackasm1(SB)
MOVD $890, R11
BR callbackasm1(SB)
MOVD $891, R11
BR callbackasm1(SB)
MOVD $892, R11
BR callbackasm1(SB)
MOVD $893, R11
BR callbackasm1(SB)
MOVD $894, R11
BR callbackasm1(SB)
MOVD $895, R11
BR callbackasm1(SB)
MOVD $896, R11
BR callbackasm1(SB)
MOVD $897, R11
BR callbackasm1(SB)
MOVD $898, R11
BR callbackasm1(SB)
MOVD $899, R11
BR callbackasm1(SB)
MOVD $900, R11
BR callbackasm1(SB)
MOVD $901, R11
BR callbackasm1(SB)
MOVD $902, R11
BR callbackasm1(SB)
MOVD $903, R11
BR callbackasm1(SB)
MOVD $904, R11
BR callbackasm1(SB)
MOVD $905, R11
BR callbackasm1(SB)
MOVD $906, R11
BR callbackasm1(SB)
MOVD $907, R11
BR callbackasm1(SB)
MOVD $908, R11
BR callbackasm1(SB)
MOVD $909, R11
BR callbackasm1(SB)
MOVD $910, R11
BR callbackasm1(SB)
MOVD $911, R11
BR callbackasm1(SB)
MOVD $912, R11
BR callbackasm1(SB)
MOVD $913, R11
BR callbackasm1(SB)
MOVD $914, R11
BR callbackasm1(SB)
MOVD $915, R11
BR callbackasm1(SB)
MOVD $916, R11
BR callbackasm1(SB)
MOVD $917, R11
BR callbackasm1(SB)
MOVD $918, R11
BR callbackasm1(SB)
MOVD $919, R11
BR callbackasm1(SB)
MOVD $920, R11
BR callbackasm1(SB)
MOVD $921, R11
BR callbackasm1(SB)
MOVD $922, R11
BR callbackasm1(SB)
MOVD $923, R11
BR callbackasm1(SB)
MOVD $924, R11
BR callbackasm1(SB)
MOVD $925, R11
BR callbackasm1(SB)
MOVD $926, R11
BR callbackasm1(SB)
MOVD $927, R11
BR callbackasm1(SB)
MOVD $928, R11
BR callbackasm1(SB)
MOVD $929, R11
BR callbackasm1(SB)
MOVD $930, R11
BR callbackasm1(SB)
MOVD $931, R11
BR callbackasm1(SB)
MOVD $932, R11
BR callbackasm1(SB)
MOVD $933, R11
BR callbackasm1(SB)
MOVD $934, R11
BR callbackasm1(SB)
MOVD $935, R11
BR callbackasm1(SB)
MOVD $936, R11
BR callbackasm1(SB)
MOVD $937, R11
BR callbackasm1(SB)
MOVD $938, R11
BR callbackasm1(SB)
MOVD $939, R11
BR callbackasm1(SB)
MOVD $940, R11
BR callbackasm1(SB)
MOVD $941, R11
BR callbackasm1(SB)
MOVD $942, R11
BR callbackasm1(SB)
MOVD $943, R11
BR callbackasm1(SB)
MOVD $944, R11
BR callbackasm1(SB)
MOVD $945, R11
BR callbackasm1(SB)
MOVD $946, R11
BR callbackasm1(SB)
MOVD $947, R11
BR callbackasm1(SB)
MOVD $948, R11
BR callbackasm1(SB)
MOVD $949, R11
BR callbackasm1(SB)
MOVD $950, R11
BR callbackasm1(SB)
MOVD $951, R11
BR callbackasm1(SB)
MOVD $952, R11
BR callbackasm1(SB)
MOVD $953, R11
BR callbackasm1(SB)
MOVD $954, R11
BR callbackasm1(SB)
MOVD $955, R11
BR callbackasm1(SB)
MOVD $956, R11
BR callbackasm1(SB)
MOVD $957, R11
BR callbackasm1(SB)
MOVD $958, R11
BR callbackasm1(SB)
MOVD $959, R11
BR callbackasm1(SB)
MOVD $960, R11
BR callbackasm1(SB)
MOVD $961, R11
BR callbackasm1(SB)
MOVD $962, R11
BR callbackasm1(SB)
MOVD $963, R11
BR callbackasm1(SB)
MOVD $964, R11
BR callbackasm1(SB)
MOVD $965, R11
BR callbackasm1(SB)
MOVD $966, R11
BR callbackasm1(SB)
MOVD $967, R11
BR callbackasm1(SB)
MOVD $968, R11
BR callbackasm1(SB)
MOVD $969, R11
BR callbackasm1(SB)
MOVD $970, R11
BR callbackasm1(SB)
MOVD $971, R11
BR callbackasm1(SB)
MOVD $972, R11
BR callbackasm1(SB)
MOVD $973, R11
BR callbackasm1(SB)
MOVD $974, R11
BR callbackasm1(SB)
MOVD $975, R11
BR callbackasm1(SB)
MOVD $976, R11
BR callbackasm1(SB)
MOVD $977, R11
BR callbackasm1(SB)
MOVD $978, R11
BR callbackasm1(SB)
MOVD $979, R11
BR callbackasm1(SB)
MOVD $980, R11
BR callbackasm1(SB)
MOVD $981, R11
BR callbackasm1(SB)
MOVD $982, R11
BR callbackasm1(SB)
MOVD $983, R11
BR callbackasm1(SB)
MOVD $984, R11
BR callbackasm1(SB)
MOVD $985, R11
BR callbackasm1(SB)
MOVD $986, R11
BR callbackasm1(SB)
MOVD $987, R11
BR callbackasm1(SB)
MOVD $988, R11
BR callbackasm1(SB)
MOVD $989, R11
BR callbackasm1(SB)
MOVD $990, R11
BR callbackasm1(SB)
MOVD $991, R11
BR callbackasm1(SB)
MOVD $992, R11
BR callbackasm1(SB)
MOVD $993, R11
BR callbackasm1(SB)
MOVD $994, R11
BR callbackasm1(SB)
MOVD $995, R11
BR callbackasm1(SB)
MOVD $996, R11
BR callbackasm1(SB)
MOVD $997, R11
BR callbackasm1(SB)
MOVD $998, R11
BR callbackasm1(SB)
MOVD $999, R11
BR callbackasm1(SB)
MOVD $1000, R11
BR callbackasm1(SB)
MOVD $1001, R11
BR callbackasm1(SB)
MOVD $1002, R11
BR callbackasm1(SB)
MOVD $1003, R11
BR callbackasm1(SB)
MOVD $1004, R11
BR callbackasm1(SB)
MOVD $1005, R11
BR callbackasm1(SB)
MOVD $1006, R11
BR callbackasm1(SB)
MOVD $1007, R11
BR callbackasm1(SB)
MOVD $1008, R11
BR callbackasm1(SB)
MOVD $1009, R11
BR callbackasm1(SB)
MOVD $1010, R11
BR callbackasm1(SB)
MOVD $1011, R11
BR callbackasm1(SB)
MOVD $1012, R11
BR callbackasm1(SB)
MOVD $1013, R11
BR callbackasm1(SB)
MOVD $1014, R11
BR callbackasm1(SB)
MOVD $1015, R11
BR callbackasm1(SB)
MOVD $1016, R11
BR callbackasm1(SB)
MOVD $1017, R11
BR callbackasm1(SB)
MOVD $1018, R11
BR callbackasm1(SB)
MOVD $1019, R11
BR callbackasm1(SB)
MOVD $1020, R11
BR callbackasm1(SB)
MOVD $1021, R11
BR callbackasm1(SB)
MOVD $1022, R11
BR callbackasm1(SB)
MOVD $1023, R11
BR callbackasm1(SB)
MOVD $1024, R11
BR callbackasm1(SB)
MOVD $1025, R11
BR callbackasm1(SB)
MOVD $1026, R11
BR callbackasm1(SB)
MOVD $1027, R11
BR callbackasm1(SB)
MOVD $1028, R11
BR callbackasm1(SB)
MOVD $1029, R11
BR callbackasm1(SB)
MOVD $1030, R11
BR callbackasm1(SB)
MOVD $1031, R11
BR callbackasm1(SB)
MOVD $1032, R11
BR callbackasm1(SB)
MOVD $1033, R11
BR callbackasm1(SB)
MOVD $1034, R11
BR callbackasm1(SB)
MOVD $1035, R11
BR callbackasm1(SB)
MOVD $1036, R11
BR callbackasm1(SB)
MOVD $1037, R11
BR callbackasm1(SB)
MOVD $1038, R11
BR callbackasm1(SB)
MOVD $1039, R11
BR callbackasm1(SB)
MOVD $1040, R11
BR callbackasm1(SB)
MOVD $1041, R11
BR callbackasm1(SB)
MOVD $1042, R11
BR callbackasm1(SB)
MOVD $1043, R11
BR callbackasm1(SB)
MOVD $1044, R11
BR callbackasm1(SB)
MOVD $1045, R11
BR callbackasm1(SB)
MOVD $1046, R11
BR callbackasm1(SB)
MOVD $1047, R11
BR callbackasm1(SB)
MOVD $1048, R11
BR callbackasm1(SB)
MOVD $1049, R11
BR callbackasm1(SB)
MOVD $1050, R11
BR callbackasm1(SB)
MOVD $1051, R11
BR callbackasm1(SB)
MOVD $1052, R11
BR callbackasm1(SB)
MOVD $1053, R11
BR callbackasm1(SB)
MOVD $1054, R11
BR callbackasm1(SB)
MOVD $1055, R11
BR callbackasm1(SB)
MOVD $1056, R11
BR callbackasm1(SB)
MOVD $1057, R11
BR callbackasm1(SB)
MOVD $1058, R11
BR callbackasm1(SB)
MOVD $1059, R11
BR callbackasm1(SB)
MOVD $1060, R11
BR callbackasm1(SB)
MOVD $1061, R11
BR callbackasm1(SB)
MOVD $1062, R11
BR callbackasm1(SB)
MOVD $1063, R11
BR callbackasm1(SB)
MOVD $1064, R11
BR callbackasm1(SB)
MOVD $1065, R11
BR callbackasm1(SB)
MOVD $1066, R11
BR callbackasm1(SB)
MOVD $1067, R11
BR callbackasm1(SB)
MOVD $1068, R11
BR callbackasm1(SB)
MOVD $1069, R11
BR callbackasm1(SB)
MOVD $1070, R11
BR callbackasm1(SB)
MOVD $1071, R11
BR callbackasm1(SB)
MOVD $1072, R11
BR callbackasm1(SB)
MOVD $1073, R11
BR callbackasm1(SB)
MOVD $1074, R11
BR callbackasm1(SB)
MOVD $1075, R11
BR callbackasm1(SB)
MOVD $1076, R11
BR callbackasm1(SB)
MOVD $1077, R11
BR callbackasm1(SB)
MOVD $1078, R11
BR callbackasm1(SB)
MOVD $1079, R11
BR callbackasm1(SB)
MOVD $1080, R11
BR callbackasm1(SB)
MOVD $1081, R11
BR callbackasm1(SB)
MOVD $1082, R11
BR callbackasm1(SB)
MOVD $1083, R11
BR callbackasm1(SB)
MOVD $1084, R11
BR callbackasm1(SB)
MOVD $1085, R11
BR callbackasm1(SB)
MOVD $1086, R11
BR callbackasm1(SB)
MOVD $1087, R11
BR callbackasm1(SB)
MOVD $1088, R11
BR callbackasm1(SB)
MOVD $1089, R11
BR callbackasm1(SB)
MOVD $1090, R11
BR callbackasm1(SB)
MOVD $1091, R11
BR callbackasm1(SB)
MOVD $1092, R11
BR callbackasm1(SB)
MOVD $1093, R11
BR callbackasm1(SB)
MOVD $1094, R11
BR callbackasm1(SB)
MOVD $1095, R11
BR callbackasm1(SB)
MOVD $1096, R11
BR callbackasm1(SB)
MOVD $1097, R11
BR callbackasm1(SB)
MOVD $1098, R11
BR callbackasm1(SB)
MOVD $1099, R11
BR callbackasm1(SB)
MOVD $1100, R11
BR callbackasm1(SB)
MOVD $1101, R11
BR callbackasm1(SB)
MOVD $1102, R11
BR callbackasm1(SB)
MOVD $1103, R11
BR callbackasm1(SB)
MOVD $1104, R11
BR callbackasm1(SB)
MOVD $1105, R11
BR callbackasm1(SB)
MOVD $1106, R11
BR callbackasm1(SB)
MOVD $1107, R11
BR callbackasm1(SB)
MOVD $1108, R11
BR callbackasm1(SB)
MOVD $1109, R11
BR callbackasm1(SB)
MOVD $1110, R11
BR callbackasm1(SB)
MOVD $1111, R11
BR callbackasm1(SB)
MOVD $1112, R11
BR callbackasm1(SB)
MOVD $1113, R11
BR callbackasm1(SB)
MOVD $1114, R11
BR callbackasm1(SB)
MOVD $1115, R11
BR callbackasm1(SB)
MOVD $1116, R11
BR callbackasm1(SB)
MOVD $1117, R11
BR callbackasm1(SB)
MOVD $1118, R11
BR callbackasm1(SB)
MOVD $1119, R11
BR callbackasm1(SB)
MOVD $1120, R11
BR callbackasm1(SB)
MOVD $1121, R11
BR callbackasm1(SB)
MOVD $1122, R11
BR callbackasm1(SB)
MOVD $1123, R11
BR callbackasm1(SB)
MOVD $1124, R11
BR callbackasm1(SB)
MOVD $1125, R11
BR callbackasm1(SB)
MOVD $1126, R11
BR callbackasm1(SB)
MOVD $1127, R11
BR callbackasm1(SB)
MOVD $1128, R11
BR callbackasm1(SB)
MOVD $1129, R11
BR callbackasm1(SB)
MOVD $1130, R11
BR callbackasm1(SB)
MOVD $1131, R11
BR callbackasm1(SB)
MOVD $1132, R11
BR callbackasm1(SB)
MOVD $1133, R11
BR callbackasm1(SB)
MOVD $1134, R11
BR callbackasm1(SB)
MOVD $1135, R11
BR callbackasm1(SB)
MOVD $1136, R11
BR callbackasm1(SB)
MOVD $1137, R11
BR callbackasm1(SB)
MOVD $1138, R11
BR callbackasm1(SB)
MOVD $1139, R11
BR callbackasm1(SB)
MOVD $1140, R11
BR callbackasm1(SB)
MOVD $1141, R11
BR callbackasm1(SB)
MOVD $1142, R11
BR callbackasm1(SB)
MOVD $1143, R11
BR callbackasm1(SB)
MOVD $1144, R11
BR callbackasm1(SB)
MOVD $1145, R11
BR callbackasm1(SB)
MOVD $1146, R11
BR callbackasm1(SB)
MOVD $1147, R11
BR callbackasm1(SB)
MOVD $1148, R11
BR callbackasm1(SB)
MOVD $1149, R11
BR callbackasm1(SB)
MOVD $1150, R11
BR callbackasm1(SB)
MOVD $1151, R11
BR callbackasm1(SB)
MOVD $1152, R11
BR callbackasm1(SB)
MOVD $1153, R11
BR callbackasm1(SB)
MOVD $1154, R11
BR callbackasm1(SB)
MOVD $1155, R11
BR callbackasm1(SB)
MOVD $1156, R11
BR callbackasm1(SB)
MOVD $1157, R11
BR callbackasm1(SB)
MOVD $1158, R11
BR callbackasm1(SB)
MOVD $1159, R11
BR callbackasm1(SB)
MOVD $1160, R11
BR callbackasm1(SB)
MOVD $1161, R11
BR callbackasm1(SB)
MOVD $1162, R11
BR callbackasm1(SB)
MOVD $1163, R11
BR callbackasm1(SB)
MOVD $1164, R11
BR callbackasm1(SB)
MOVD $1165, R11
BR callbackasm1(SB)
MOVD $1166, R11
BR callbackasm1(SB)
MOVD $1167, R11
BR callbackasm1(SB)
MOVD $1168, R11
BR callbackasm1(SB)
MOVD $1169, R11
BR callbackasm1(SB)
MOVD $1170, R11
BR callbackasm1(SB)
MOVD $1171, R11
BR callbackasm1(SB)
MOVD $1172, R11
BR callbackasm1(SB)
MOVD $1173, R11
BR callbackasm1(SB)
MOVD $1174, R11
BR callbackasm1(SB)
MOVD $1175, R11
BR callbackasm1(SB)
MOVD $1176, R11
BR callbackasm1(SB)
MOVD $1177, R11
BR callbackasm1(SB)
MOVD $1178, R11
BR callbackasm1(SB)
MOVD $1179, R11
BR callbackasm1(SB)
MOVD $1180, R11
BR callbackasm1(SB)
MOVD $1181, R11
BR callbackasm1(SB)
MOVD $1182, R11
BR callbackasm1(SB)
MOVD $1183, R11
BR callbackasm1(SB)
MOVD $1184, R11
BR callbackasm1(SB)
MOVD $1185, R11
BR callbackasm1(SB)
MOVD $1186, R11
BR callbackasm1(SB)
MOVD $1187, R11
BR callbackasm1(SB)
MOVD $1188, R11
BR callbackasm1(SB)
MOVD $1189, R11
BR callbackasm1(SB)
MOVD $1190, R11
BR callbackasm1(SB)
MOVD $1191, R11
BR callbackasm1(SB)
MOVD $1192, R11
BR callbackasm1(SB)
MOVD $1193, R11
BR callbackasm1(SB)
MOVD $1194, R11
BR callbackasm1(SB)
MOVD $1195, R11
BR callbackasm1(SB)
MOVD $1196, R11
BR callbackasm1(SB)
MOVD $1197, R11
BR callbackasm1(SB)
MOVD $1198, R11
BR callbackasm1(SB)
MOVD $1199, R11
BR callbackasm1(SB)
MOVD $1200, R11
BR callbackasm1(SB)
MOVD $1201, R11
BR callbackasm1(SB)
MOVD $1202, R11
BR callbackasm1(SB)
MOVD $1203, R11
BR callbackasm1(SB)
MOVD $1204, R11
BR callbackasm1(SB)
MOVD $1205, R11
BR callbackasm1(SB)
MOVD $1206, R11
BR callbackasm1(SB)
MOVD $1207, R11
BR callbackasm1(SB)
MOVD $1208, R11
BR callbackasm1(SB)
MOVD $1209, R11
BR callbackasm1(SB)
MOVD $1210, R11
BR callbackasm1(SB)
MOVD $1211, R11
BR callbackasm1(SB)
MOVD $1212, R11
BR callbackasm1(SB)
MOVD $1213, R11
BR callbackasm1(SB)
MOVD $1214, R11
BR callbackasm1(SB)
MOVD $1215, R11
BR callbackasm1(SB)
MOVD $1216, R11
BR callbackasm1(SB)
MOVD $1217, R11
BR callbackasm1(SB)
MOVD $1218, R11
BR callbackasm1(SB)
MOVD $1219, R11
BR callbackasm1(SB)
MOVD $1220, R11
BR callbackasm1(SB)
MOVD $1221, R11
BR callbackasm1(SB)
MOVD $1222, R11
BR callbackasm1(SB)
MOVD $1223, R11
BR callbackasm1(SB)
MOVD $1224, R11
BR callbackasm1(SB)
MOVD $1225, R11
BR callbackasm1(SB)
MOVD $1226, R11
BR callbackasm1(SB)
MOVD $1227, R11
BR callbackasm1(SB)
MOVD $1228, R11
BR callbackasm1(SB)
MOVD $1229, R11
BR callbackasm1(SB)
MOVD $1230, R11
BR callbackasm1(SB)
MOVD $1231, R11
BR callbackasm1(SB)
MOVD $1232, R11
BR callbackasm1(SB)
MOVD $1233, R11
BR callbackasm1(SB)
MOVD $1234, R11
BR callbackasm1(SB)
MOVD $1235, R11
BR callbackasm1(SB)
MOVD $1236, R11
BR callbackasm1(SB)
MOVD $1237, R11
BR callbackasm1(SB)
MOVD $1238, R11
BR callbackasm1(SB)
MOVD $1239, R11
BR callbackasm1(SB)
MOVD $1240, R11
BR callbackasm1(SB)
MOVD $1241, R11
BR callbackasm1(SB)
MOVD $1242, R11
BR callbackasm1(SB)
MOVD $1243, R11
BR callbackasm1(SB)
MOVD $1244, R11
BR callbackasm1(SB)
MOVD $1245, R11
BR callbackasm1(SB)
MOVD $1246, R11
BR callbackasm1(SB)
MOVD $1247, R11
BR callbackasm1(SB)
MOVD $1248, R11
BR callbackasm1(SB)
MOVD $1249, R11
BR callbackasm1(SB)
MOVD $1250, R11
BR callbackasm1(SB)
MOVD $1251, R11
BR callbackasm1(SB)
MOVD $1252, R11
BR callbackasm1(SB)
MOVD $1253, R11
BR callbackasm1(SB)
MOVD $1254, R11
BR callbackasm1(SB)
MOVD $1255, R11
BR callbackasm1(SB)
MOVD $1256, R11
BR callbackasm1(SB)
MOVD $1257, R11
BR callbackasm1(SB)
MOVD $1258, R11
BR callbackasm1(SB)
MOVD $1259, R11
BR callbackasm1(SB)
MOVD $1260, R11
BR callbackasm1(SB)
MOVD $1261, R11
BR callbackasm1(SB)
MOVD $1262, R11
BR callbackasm1(SB)
MOVD $1263, R11
BR callbackasm1(SB)
MOVD $1264, R11
BR callbackasm1(SB)
MOVD $1265, R11
BR callbackasm1(SB)
MOVD $1266, R11
BR callbackasm1(SB)
MOVD $1267, R11
BR callbackasm1(SB)
MOVD $1268, R11
BR callbackasm1(SB)
MOVD $1269, R11
BR callbackasm1(SB)
MOVD $1270, R11
BR callbackasm1(SB)
MOVD $1271, R11
BR callbackasm1(SB)
MOVD $1272, R11
BR callbackasm1(SB)
MOVD $1273, R11
BR callbackasm1(SB)
MOVD $1274, R11
BR callbackasm1(SB)
MOVD $1275, R11
BR callbackasm1(SB)
MOVD $1276, R11
BR callbackasm1(SB)
MOVD $1277, R11
BR callbackasm1(SB)
MOVD $1278, R11
BR callbackasm1(SB)
MOVD $1279, R11
BR callbackasm1(SB)
MOVD $1280, R11
BR callbackasm1(SB)
MOVD $1281, R11
BR callbackasm1(SB)
MOVD $1282, R11
BR callbackasm1(SB)
MOVD $1283, R11
BR callbackasm1(SB)
MOVD $1284, R11
BR callbackasm1(SB)
MOVD $1285, R11
BR callbackasm1(SB)
MOVD $1286, R11
BR callbackasm1(SB)
MOVD $1287, R11
BR callbackasm1(SB)
MOVD $1288, R11
BR callbackasm1(SB)
MOVD $1289, R11
BR callbackasm1(SB)
MOVD $1290, R11
BR callbackasm1(SB)
MOVD $1291, R11
BR callbackasm1(SB)
MOVD $1292, R11
BR callbackasm1(SB)
MOVD $1293, R11
BR callbackasm1(SB)
MOVD $1294, R11
BR callbackasm1(SB)
MOVD $1295, R11
BR callbackasm1(SB)
MOVD $1296, R11
BR callbackasm1(SB)
MOVD $1297, R11
BR callbackasm1(SB)
MOVD $1298, R11
BR callbackasm1(SB)
MOVD $1299, R11
BR callbackasm1(SB)
MOVD $1300, R11
BR callbackasm1(SB)
MOVD $1301, R11
BR callbackasm1(SB)
MOVD $1302, R11
BR callbackasm1(SB)
MOVD $1303, R11
BR callbackasm1(SB)
MOVD $1304, R11
BR callbackasm1(SB)
MOVD $1305, R11
BR callbackasm1(SB)
MOVD $1306, R11
BR callbackasm1(SB)
MOVD $1307, R11
BR callbackasm1(SB)
MOVD $1308, R11
BR callbackasm1(SB)
MOVD $1309, R11
BR callbackasm1(SB)
MOVD $1310, R11
BR callbackasm1(SB)
MOVD $1311, R11
BR callbackasm1(SB)
MOVD $1312, R11
BR callbackasm1(SB)
MOVD $1313, R11
BR callbackasm1(SB)
MOVD $1314, R11
BR callbackasm1(SB)
MOVD $1315, R11
BR callbackasm1(SB)
MOVD $1316, R11
BR callbackasm1(SB)
MOVD $1317, R11
BR callbackasm1(SB)
MOVD $1318, R11
BR callbackasm1(SB)
MOVD $1319, R11
BR callbackasm1(SB)
MOVD $1320, R11
BR callbackasm1(SB)
MOVD $1321, R11
BR callbackasm1(SB)
MOVD $1322, R11
BR callbackasm1(SB)
MOVD $1323, R11
BR callbackasm1(SB)
MOVD $1324, R11
BR callbackasm1(SB)
MOVD $1325, R11
BR callbackasm1(SB)
MOVD $1326, R11
BR callbackasm1(SB)
MOVD $1327, R11
BR callbackasm1(SB)
MOVD $1328, R11
BR callbackasm1(SB)
MOVD $1329, R11
BR callbackasm1(SB)
MOVD $1330, R11
BR callbackasm1(SB)
MOVD $1331, R11
BR callbackasm1(SB)
MOVD $1332, R11
BR callbackasm1(SB)
MOVD $1333, R11
BR callbackasm1(SB)
MOVD $1334, R11
BR callbackasm1(SB)
MOVD $1335, R11
BR callbackasm1(SB)
MOVD $1336, R11
BR callbackasm1(SB)
MOVD $1337, R11
BR callbackasm1(SB)
MOVD $1338, R11
BR callbackasm1(SB)
MOVD $1339, R11
BR callbackasm1(SB)
MOVD $1340, R11
BR callbackasm1(SB)
MOVD $1341, R11
BR callbackasm1(SB)
MOVD $1342, R11
BR callbackasm1(SB)
MOVD $1343, R11
BR callbackasm1(SB)
MOVD $1344, R11
BR callbackasm1(SB)
MOVD $1345, R11
BR callbackasm1(SB)
MOVD $1346, R11
BR callbackasm1(SB)
MOVD $1347, R11
BR callbackasm1(SB)
MOVD $1348, R11
BR callbackasm1(SB)
MOVD $1349, R11
BR callbackasm1(SB)
MOVD $1350, R11
BR callbackasm1(SB)
MOVD $1351, R11
BR callbackasm1(SB)
MOVD $1352, R11
BR callbackasm1(SB)
MOVD $1353, R11
BR callbackasm1(SB)
MOVD $1354, R11
BR callbackasm1(SB)
MOVD $1355, R11
BR callbackasm1(SB)
MOVD $1356, R11
BR callbackasm1(SB)
MOVD $1357, R11
BR callbackasm1(SB)
MOVD $1358, R11
BR callbackasm1(SB)
MOVD $1359, R11
BR callbackasm1(SB)
MOVD $1360, R11
BR callbackasm1(SB)
MOVD $1361, R11
BR callbackasm1(SB)
MOVD $1362, R11
BR callbackasm1(SB)
MOVD $1363, R11
BR callbackasm1(SB)
MOVD $1364, R11
BR callbackasm1(SB)
MOVD $1365, R11
BR callbackasm1(SB)
MOVD $1366, R11
BR callbackasm1(SB)
MOVD $1367, R11
BR callbackasm1(SB)
MOVD $1368, R11
BR callbackasm1(SB)
MOVD $1369, R11
BR callbackasm1(SB)
MOVD $1370, R11
BR callbackasm1(SB)
MOVD $1371, R11
BR callbackasm1(SB)
MOVD $1372, R11
BR callbackasm1(SB)
MOVD $1373, R11
BR callbackasm1(SB)
MOVD $1374, R11
BR callbackasm1(SB)
MOVD $1375, R11
BR callbackasm1(SB)
MOVD $1376, R11
BR callbackasm1(SB)
MOVD $1377, R11
BR callbackasm1(SB)
MOVD $1378, R11
BR callbackasm1(SB)
MOVD $1379, R11
BR callbackasm1(SB)
MOVD $1380, R11
BR callbackasm1(SB)
MOVD $1381, R11
BR callbackasm1(SB)
MOVD $1382, R11
BR callbackasm1(SB)
MOVD $1383, R11
BR callbackasm1(SB)
MOVD $1384, R11
BR callbackasm1(SB)
MOVD $1385, R11
BR callbackasm1(SB)
MOVD $1386, R11
BR callbackasm1(SB)
MOVD $1387, R11
BR callbackasm1(SB)
MOVD $1388, R11
BR callbackasm1(SB)
MOVD $1389, R11
BR callbackasm1(SB)
MOVD $1390, R11
BR callbackasm1(SB)
MOVD $1391, R11
BR callbackasm1(SB)
MOVD $1392, R11
BR callbackasm1(SB)
MOVD $1393, R11
BR callbackasm1(SB)
MOVD $1394, R11
BR callbackasm1(SB)
MOVD $1395, R11
BR callbackasm1(SB)
MOVD $1396, R11
BR callbackasm1(SB)
MOVD $1397, R11
BR callbackasm1(SB)
MOVD $1398, R11
BR callbackasm1(SB)
MOVD $1399, R11
BR callbackasm1(SB)
MOVD $1400, R11
BR callbackasm1(SB)
MOVD $1401, R11
BR callbackasm1(SB)
MOVD $1402, R11
BR callbackasm1(SB)
MOVD $1403, R11
BR callbackasm1(SB)
MOVD $1404, R11
BR callbackasm1(SB)
MOVD $1405, R11
BR callbackasm1(SB)
MOVD $1406, R11
BR callbackasm1(SB)
MOVD $1407, R11
BR callbackasm1(SB)
MOVD $1408, R11
BR callbackasm1(SB)
MOVD $1409, R11
BR callbackasm1(SB)
MOVD $1410, R11
BR callbackasm1(SB)
MOVD $1411, R11
BR callbackasm1(SB)
MOVD $1412, R11
BR callbackasm1(SB)
MOVD $1413, R11
BR callbackasm1(SB)
MOVD $1414, R11
BR callbackasm1(SB)
MOVD $1415, R11
BR callbackasm1(SB)
MOVD $1416, R11
BR callbackasm1(SB)
MOVD $1417, R11
BR callbackasm1(SB)
MOVD $1418, R11
BR callbackasm1(SB)
MOVD $1419, R11
BR callbackasm1(SB)
MOVD $1420, R11
BR callbackasm1(SB)
MOVD $1421, R11
BR callbackasm1(SB)
MOVD $1422, R11
BR callbackasm1(SB)
MOVD $1423, R11
BR callbackasm1(SB)
MOVD $1424, R11
BR callbackasm1(SB)
MOVD $1425, R11
BR callbackasm1(SB)
MOVD $1426, R11
BR callbackasm1(SB)
MOVD $1427, R11
BR callbackasm1(SB)
MOVD $1428, R11
BR callbackasm1(SB)
MOVD $1429, R11
BR callbackasm1(SB)
MOVD $1430, R11
BR callbackasm1(SB)
MOVD $1431, R11
BR callbackasm1(SB)
MOVD $1432, R11
BR callbackasm1(SB)
MOVD $1433, R11
BR callbackasm1(SB)
MOVD $1434, R11
BR callbackasm1(SB)
MOVD $1435, R11
BR callbackasm1(SB)
MOVD $1436, R11
BR callbackasm1(SB)
MOVD $1437, R11
BR callbackasm1(SB)
MOVD $1438, R11
BR callbackasm1(SB)
MOVD $1439, R11
BR callbackasm1(SB)
MOVD $1440, R11
BR callbackasm1(SB)
MOVD $1441, R11
BR callbackasm1(SB)
MOVD $1442, R11
BR callbackasm1(SB)
MOVD $1443, R11
BR callbackasm1(SB)
MOVD $1444, R11
BR callbackasm1(SB)
MOVD $1445, R11
BR callbackasm1(SB)
MOVD $1446, R11
BR callbackasm1(SB)
MOVD $1447, R11
BR callbackasm1(SB)
MOVD $1448, R11
BR callbackasm1(SB)
MOVD $1449, R11
BR callbackasm1(SB)
MOVD $1450, R11
BR callbackasm1(SB)
MOVD $1451, R11
BR callbackasm1(SB)
MOVD $1452, R11
BR callbackasm1(SB)
MOVD $1453, R11
BR callbackasm1(SB)
MOVD $1454, R11
BR callbackasm1(SB)
MOVD $1455, R11
BR callbackasm1(SB)
MOVD $1456, R11
BR callbackasm1(SB)
MOVD $1457, R11
BR callbackasm1(SB)
MOVD $1458, R11
BR callbackasm1(SB)
MOVD $1459, R11
BR callbackasm1(SB)
MOVD $1460, R11
BR callbackasm1(SB)
MOVD $1461, R11
BR callbackasm1(SB)
MOVD $1462, R11
BR callbackasm1(SB)
MOVD $1463, R11
BR callbackasm1(SB)
MOVD $1464, R11
BR callbackasm1(SB)
MOVD $1465, R11
BR callbackasm1(SB)
MOVD $1466, R11
BR callbackasm1(SB)
MOVD $1467, R11
BR callbackasm1(SB)
MOVD $1468, R11
BR callbackasm1(SB)
MOVD $1469, R11
BR callbackasm1(SB)
MOVD $1470, R11
BR callbackasm1(SB)
MOVD $1471, R11
BR callbackasm1(SB)
MOVD $1472, R11
BR callbackasm1(SB)
MOVD $1473, R11
BR callbackasm1(SB)
MOVD $1474, R11
BR callbackasm1(SB)
MOVD $1475, R11
BR callbackasm1(SB)
MOVD $1476, R11
BR callbackasm1(SB)
MOVD $1477, R11
BR callbackasm1(SB)
MOVD $1478, R11
BR callbackasm1(SB)
MOVD $1479, R11
BR callbackasm1(SB)
MOVD $1480, R11
BR callbackasm1(SB)
MOVD $1481, R11
BR callbackasm1(SB)
MOVD $1482, R11
BR callbackasm1(SB)
MOVD $1483, R11
BR callbackasm1(SB)
MOVD $1484, R11
BR callbackasm1(SB)
MOVD $1485, R11
BR callbackasm1(SB)
MOVD $1486, R11
BR callbackasm1(SB)
MOVD $1487, R11
BR callbackasm1(SB)
MOVD $1488, R11
BR callbackasm1(SB)
MOVD $1489, R11
BR callbackasm1(SB)
MOVD $1490, R11
BR callbackasm1(SB)
MOVD $1491, R11
BR callbackasm1(SB)
MOVD $1492, R11
BR callbackasm1(SB)
MOVD $1493, R11
BR callbackasm1(SB)
MOVD $1494, R11
BR callbackasm1(SB)
MOVD $1495, R11
BR callbackasm1(SB)
MOVD $1496, R11
BR callbackasm1(SB)
MOVD $1497, R11
BR callbackasm1(SB)
MOVD $1498, R11
BR callbackasm1(SB)
MOVD $1499, R11
BR callbackasm1(SB)
MOVD $1500, R11
BR callbackasm1(SB)
MOVD $1501, R11
BR callbackasm1(SB)
MOVD $1502, R11
BR callbackasm1(SB)
MOVD $1503, R11
BR callbackasm1(SB)
MOVD $1504, R11
BR callbackasm1(SB)
MOVD $1505, R11
BR callbackasm1(SB)
MOVD $1506, R11
BR callbackasm1(SB)
MOVD $1507, R11
BR callbackasm1(SB)
MOVD $1508, R11
BR callbackasm1(SB)
MOVD $1509, R11
BR callbackasm1(SB)
MOVD $1510, R11
BR callbackasm1(SB)
MOVD $1511, R11
BR callbackasm1(SB)
MOVD $1512, R11
BR callbackasm1(SB)
MOVD $1513, R11
BR callbackasm1(SB)
MOVD $1514, R11
BR callbackasm1(SB)
MOVD $1515, R11
BR callbackasm1(SB)
MOVD $1516, R11
BR callbackasm1(SB)
MOVD $1517, R11
BR callbackasm1(SB)
MOVD $1518, R11
BR callbackasm1(SB)
MOVD $1519, R11
BR callbackasm1(SB)
MOVD $1520, R11
BR callbackasm1(SB)
MOVD $1521, R11
BR callbackasm1(SB)
MOVD $1522, R11
BR callbackasm1(SB)
MOVD $1523, R11
BR callbackasm1(SB)
MOVD $1524, R11
BR callbackasm1(SB)
MOVD $1525, R11
BR callbackasm1(SB)
MOVD $1526, R11
BR callbackasm1(SB)
MOVD $1527, R11
BR callbackasm1(SB)
MOVD $1528, R11
BR callbackasm1(SB)
MOVD $1529, R11
BR callbackasm1(SB)
MOVD $1530, R11
BR callbackasm1(SB)
MOVD $1531, R11
BR callbackasm1(SB)
MOVD $1532, R11
BR callbackasm1(SB)
MOVD $1533, R11
BR callbackasm1(SB)
MOVD $1534, R11
BR callbackasm1(SB)
MOVD $1535, R11
BR callbackasm1(SB)
MOVD $1536, R11
BR callbackasm1(SB)
MOVD $1537, R11
BR callbackasm1(SB)
MOVD $1538, R11
BR callbackasm1(SB)
MOVD $1539, R11
BR callbackasm1(SB)
MOVD $1540, R11
BR callbackasm1(SB)
MOVD $1541, R11
BR callbackasm1(SB)
MOVD $1542, R11
BR callbackasm1(SB)
MOVD $1543, R11
BR callbackasm1(SB)
MOVD $1544, R11
BR callbackasm1(SB)
MOVD $1545, R11
BR callbackasm1(SB)
MOVD $1546, R11
BR callbackasm1(SB)
MOVD $1547, R11
BR callbackasm1(SB)
MOVD $1548, R11
BR callbackasm1(SB)
MOVD $1549, R11
BR callbackasm1(SB)
MOVD $1550, R11
BR callbackasm1(SB)
MOVD $1551, R11
BR callbackasm1(SB)
MOVD $1552, R11
BR callbackasm1(SB)
MOVD $1553, R11
BR callbackasm1(SB)
MOVD $1554, R11
BR callbackasm1(SB)
MOVD $1555, R11
BR callbackasm1(SB)
MOVD $1556, R11
BR callbackasm1(SB)
MOVD $1557, R11
BR callbackasm1(SB)
MOVD $1558, R11
BR callbackasm1(SB)
MOVD $1559, R11
BR callbackasm1(SB)
MOVD $1560, R11
BR callbackasm1(SB)
MOVD $1561, R11
BR callbackasm1(SB)
MOVD $1562, R11
BR callbackasm1(SB)
MOVD $1563, R11
BR callbackasm1(SB)
MOVD $1564, R11
BR callbackasm1(SB)
MOVD $1565, R11
BR callbackasm1(SB)
MOVD $1566, R11
BR callbackasm1(SB)
MOVD $1567, R11
BR callbackasm1(SB)
MOVD $1568, R11
BR callbackasm1(SB)
MOVD $1569, R11
BR callbackasm1(SB)
MOVD $1570, R11
BR callbackasm1(SB)
MOVD $1571, R11
BR callbackasm1(SB)
MOVD $1572, R11
BR callbackasm1(SB)
MOVD $1573, R11
BR callbackasm1(SB)
MOVD $1574, R11
BR callbackasm1(SB)
MOVD $1575, R11
BR callbackasm1(SB)
MOVD $1576, R11
BR callbackasm1(SB)
MOVD $1577, R11
BR callbackasm1(SB)
MOVD $1578, R11
BR callbackasm1(SB)
MOVD $1579, R11
BR callbackasm1(SB)
MOVD $1580, R11
BR callbackasm1(SB)
MOVD $1581, R11
BR callbackasm1(SB)
MOVD $1582, R11
BR callbackasm1(SB)
MOVD $1583, R11
BR callbackasm1(SB)
MOVD $1584, R11
BR callbackasm1(SB)
MOVD $1585, R11
BR callbackasm1(SB)
MOVD $1586, R11
BR callbackasm1(SB)
MOVD $1587, R11
BR callbackasm1(SB)
MOVD $1588, R11
BR callbackasm1(SB)
MOVD $1589, R11
BR callbackasm1(SB)
MOVD $1590, R11
BR callbackasm1(SB)
MOVD $1591, R11
BR callbackasm1(SB)
MOVD $1592, R11
BR callbackasm1(SB)
MOVD $1593, R11
BR callbackasm1(SB)
MOVD $1594, R11
BR callbackasm1(SB)
MOVD $1595, R11
BR callbackasm1(SB)
MOVD $1596, R11
BR callbackasm1(SB)
MOVD $1597, R11
BR callbackasm1(SB)
MOVD $1598, R11
BR callbackasm1(SB)
MOVD $1599, R11
BR callbackasm1(SB)
MOVD $1600, R11
BR callbackasm1(SB)
MOVD $1601, R11
BR callbackasm1(SB)
MOVD $1602, R11
BR callbackasm1(SB)
MOVD $1603, R11
BR callbackasm1(SB)
MOVD $1604, R11
BR callbackasm1(SB)
MOVD $1605, R11
BR callbackasm1(SB)
MOVD $1606, R11
BR callbackasm1(SB)
MOVD $1607, R11
BR callbackasm1(SB)
MOVD $1608, R11
BR callbackasm1(SB)
MOVD $1609, R11
BR callbackasm1(SB)
MOVD $1610, R11
BR callbackasm1(SB)
MOVD $1611, R11
BR callbackasm1(SB)
MOVD $1612, R11
BR callbackasm1(SB)
MOVD $1613, R11
BR callbackasm1(SB)
MOVD $1614, R11
BR callbackasm1(SB)
MOVD $1615, R11
BR callbackasm1(SB)
MOVD $1616, R11
BR callbackasm1(SB)
MOVD $1617, R11
BR callbackasm1(SB)
MOVD $1618, R11
BR callbackasm1(SB)
MOVD $1619, R11
BR callbackasm1(SB)
MOVD $1620, R11
BR callbackasm1(SB)
MOVD $1621, R11
BR callbackasm1(SB)
MOVD $1622, R11
BR callbackasm1(SB)
MOVD $1623, R11
BR callbackasm1(SB)
MOVD $1624, R11
BR callbackasm1(SB)
MOVD $1625, R11
BR callbackasm1(SB)
MOVD $1626, R11
BR callbackasm1(SB)
MOVD $1627, R11
BR callbackasm1(SB)
MOVD $1628, R11
BR callbackasm1(SB)
MOVD $1629, R11
BR callbackasm1(SB)
MOVD $1630, R11
BR callbackasm1(SB)
MOVD $1631, R11
BR callbackasm1(SB)
MOVD $1632, R11
BR callbackasm1(SB)
MOVD $1633, R11
BR callbackasm1(SB)
MOVD $1634, R11
BR callbackasm1(SB)
MOVD $1635, R11
BR callbackasm1(SB)
MOVD $1636, R11
BR callbackasm1(SB)
MOVD $1637, R11
BR callbackasm1(SB)
MOVD $1638, R11
BR callbackasm1(SB)
MOVD $1639, R11
BR callbackasm1(SB)
MOVD $1640, R11
BR callbackasm1(SB)
MOVD $1641, R11
BR callbackasm1(SB)
MOVD $1642, R11
BR callbackasm1(SB)
MOVD $1643, R11
BR callbackasm1(SB)
MOVD $1644, R11
BR callbackasm1(SB)
MOVD $1645, R11
BR callbackasm1(SB)
MOVD $1646, R11
BR callbackasm1(SB)
MOVD $1647, R11
BR callbackasm1(SB)
MOVD $1648, R11
BR callbackasm1(SB)
MOVD $1649, R11
BR callbackasm1(SB)
MOVD $1650, R11
BR callbackasm1(SB)
MOVD $1651, R11
BR callbackasm1(SB)
MOVD $1652, R11
BR callbackasm1(SB)
MOVD $1653, R11
BR callbackasm1(SB)
MOVD $1654, R11
BR callbackasm1(SB)
MOVD $1655, R11
BR callbackasm1(SB)
MOVD $1656, R11
BR callbackasm1(SB)
MOVD $1657, R11
BR callbackasm1(SB)
MOVD $1658, R11
BR callbackasm1(SB)
MOVD $1659, R11
BR callbackasm1(SB)
MOVD $1660, R11
BR callbackasm1(SB)
MOVD $1661, R11
BR callbackasm1(SB)
MOVD $1662, R11
BR callbackasm1(SB)
MOVD $1663, R11
BR callbackasm1(SB)
MOVD $1664, R11
BR callbackasm1(SB)
MOVD $1665, R11
BR callbackasm1(SB)
MOVD $1666, R11
BR callbackasm1(SB)
MOVD $1667, R11
BR callbackasm1(SB)
MOVD $1668, R11
BR callbackasm1(SB)
MOVD $1669, R11
BR callbackasm1(SB)
MOVD $1670, R11
BR callbackasm1(SB)
MOVD $1671, R11
BR callbackasm1(SB)
MOVD $1672, R11
BR callbackasm1(SB)
MOVD $1673, R11
BR callbackasm1(SB)
MOVD $1674, R11
BR callbackasm1(SB)
MOVD $1675, R11
BR callbackasm1(SB)
MOVD $1676, R11
BR callbackasm1(SB)
MOVD $1677, R11
BR callbackasm1(SB)
MOVD $1678, R11
BR callbackasm1(SB)
MOVD $1679, R11
BR callbackasm1(SB)
MOVD $1680, R11
BR callbackasm1(SB)
MOVD $1681, R11
BR callbackasm1(SB)
MOVD $1682, R11
BR callbackasm1(SB)
MOVD $1683, R11
BR callbackasm1(SB)
MOVD $1684, R11
BR callbackasm1(SB)
MOVD $1685, R11
BR callbackasm1(SB)
MOVD $1686, R11
BR callbackasm1(SB)
MOVD $1687, R11
BR callbackasm1(SB)
MOVD $1688, R11
BR callbackasm1(SB)
MOVD $1689, R11
BR callbackasm1(SB)
MOVD $1690, R11
BR callbackasm1(SB)
MOVD $1691, R11
BR callbackasm1(SB)
MOVD $1692, R11
BR callbackasm1(SB)
MOVD $1693, R11
BR callbackasm1(SB)
MOVD $1694, R11
BR callbackasm1(SB)
MOVD $1695, R11
BR callbackasm1(SB)
MOVD $1696, R11
BR callbackasm1(SB)
MOVD $1697, R11
BR callbackasm1(SB)
MOVD $1698, R11
BR callbackasm1(SB)
MOVD $1699, R11
BR callbackasm1(SB)
MOVD $1700, R11
BR callbackasm1(SB)
MOVD $1701, R11
BR callbackasm1(SB)
MOVD $1702, R11
BR callbackasm1(SB)
MOVD $1703, R11
BR callbackasm1(SB)
MOVD $1704, R11
BR callbackasm1(SB)
MOVD $1705, R11
BR callbackasm1(SB)
MOVD $1706, R11
BR callbackasm1(SB)
MOVD $1707, R11
BR callbackasm1(SB)
MOVD $1708, R11
BR callbackasm1(SB)
MOVD $1709, R11
BR callbackasm1(SB)
MOVD $1710, R11
BR callbackasm1(SB)
MOVD $1711, R11
BR callbackasm1(SB)
MOVD $1712, R11
BR callbackasm1(SB)
MOVD $1713, R11
BR callbackasm1(SB)
MOVD $1714, R11
BR callbackasm1(SB)
MOVD $1715, R11
BR callbackasm1(SB)
MOVD $1716, R11
BR callbackasm1(SB)
MOVD $1717, R11
BR callbackasm1(SB)
MOVD $1718, R11
BR callbackasm1(SB)
MOVD $1719, R11
BR callbackasm1(SB)
MOVD $1720, R11
BR callbackasm1(SB)
MOVD $1721, R11
BR callbackasm1(SB)
MOVD $1722, R11
BR callbackasm1(SB)
MOVD $1723, R11
BR callbackasm1(SB)
MOVD $1724, R11
BR callbackasm1(SB)
MOVD $1725, R11
BR callbackasm1(SB)
MOVD $1726, R11
BR callbackasm1(SB)
MOVD $1727, R11
BR callbackasm1(SB)
MOVD $1728, R11
BR callbackasm1(SB)
MOVD $1729, R11
BR callbackasm1(SB)
MOVD $1730, R11
BR callbackasm1(SB)
MOVD $1731, R11
BR callbackasm1(SB)
MOVD $1732, R11
BR callbackasm1(SB)
MOVD $1733, R11
BR callbackasm1(SB)
MOVD $1734, R11
BR callbackasm1(SB)
MOVD $1735, R11
BR callbackasm1(SB)
MOVD $1736, R11
BR callbackasm1(SB)
MOVD $1737, R11
BR callbackasm1(SB)
MOVD $1738, R11
BR callbackasm1(SB)
MOVD $1739, R11
BR callbackasm1(SB)
MOVD $1740, R11
BR callbackasm1(SB)
MOVD $1741, R11
BR callbackasm1(SB)
MOVD $1742, R11
BR callbackasm1(SB)
MOVD $1743, R11
BR callbackasm1(SB)
MOVD $1744, R11
BR callbackasm1(SB)
MOVD $1745, R11
BR callbackasm1(SB)
MOVD $1746, R11
BR callbackasm1(SB)
MOVD $1747, R11
BR callbackasm1(SB)
MOVD $1748, R11
BR callbackasm1(SB)
MOVD $1749, R11
BR callbackasm1(SB)
MOVD $1750, R11
BR callbackasm1(SB)
MOVD $1751, R11
BR callbackasm1(SB)
MOVD $1752, R11
BR callbackasm1(SB)
MOVD $1753, R11
BR callbackasm1(SB)
MOVD $1754, R11
BR callbackasm1(SB)
MOVD $1755, R11
BR callbackasm1(SB)
MOVD $1756, R11
BR callbackasm1(SB)
MOVD $1757, R11
BR callbackasm1(SB)
MOVD $1758, R11
BR callbackasm1(SB)
MOVD $1759, R11
BR callbackasm1(SB)
MOVD $1760, R11
BR callbackasm1(SB)
MOVD $1761, R11
BR callbackasm1(SB)
MOVD $1762, R11
BR callbackasm1(SB)
MOVD $1763, R11
BR callbackasm1(SB)
MOVD $1764, R11
BR callbackasm1(SB)
MOVD $1765, R11
BR callbackasm1(SB)
MOVD $1766, R11
BR callbackasm1(SB)
MOVD $1767, R11
BR callbackasm1(SB)
MOVD $1768, R11
BR callbackasm1(SB)
MOVD $1769, R11
BR callbackasm1(SB)
MOVD $1770, R11
BR callbackasm1(SB)
MOVD $1771, R11
BR callbackasm1(SB)
MOVD $1772, R11
BR callbackasm1(SB)
MOVD $1773, R11
BR callbackasm1(SB)
MOVD $1774, R11
BR callbackasm1(SB)
MOVD $1775, R11
BR callbackasm1(SB)
MOVD $1776, R11
BR callbackasm1(SB)
MOVD $1777, R11
BR callbackasm1(SB)
MOVD $1778, R11
BR callbackasm1(SB)
MOVD $1779, R11
BR callbackasm1(SB)
MOVD $1780, R11
BR callbackasm1(SB)
MOVD $1781, R11
BR callbackasm1(SB)
MOVD $1782, R11
BR callbackasm1(SB)
MOVD $1783, R11
BR callbackasm1(SB)
MOVD $1784, R11
BR callbackasm1(SB)
MOVD $1785, R11
BR callbackasm1(SB)
MOVD $1786, R11
BR callbackasm1(SB)
MOVD $1787, R11
BR callbackasm1(SB)
MOVD $1788, R11
BR callbackasm1(SB)
MOVD $1789, R11
BR callbackasm1(SB)
MOVD $1790, R11
BR callbackasm1(SB)
MOVD $1791, R11
BR callbackasm1(SB)
MOVD $1792, R11
BR callbackasm1(SB)
MOVD $1793, R11
BR callbackasm1(SB)
MOVD $1794, R11
BR callbackasm1(SB)
MOVD $1795, R11
BR callbackasm1(SB)
MOVD $1796, R11
BR callbackasm1(SB)
MOVD $1797, R11
BR callbackasm1(SB)
MOVD $1798, R11
BR callbackasm1(SB)
MOVD $1799, R11
BR callbackasm1(SB)
MOVD $1800, R11
BR callbackasm1(SB)
MOVD $1801, R11
BR callbackasm1(SB)
MOVD $1802, R11
BR callbackasm1(SB)
MOVD $1803, R11
BR callbackasm1(SB)
MOVD $1804, R11
BR callbackasm1(SB)
MOVD $1805, R11
BR callbackasm1(SB)
MOVD $1806, R11
BR callbackasm1(SB)
MOVD $1807, R11
BR callbackasm1(SB)
MOVD $1808, R11
BR callbackasm1(SB)
MOVD $1809, R11
BR callbackasm1(SB)
MOVD $1810, R11
BR callbackasm1(SB)
MOVD $1811, R11
BR callbackasm1(SB)
MOVD $1812, R11
BR callbackasm1(SB)
MOVD $1813, R11
BR callbackasm1(SB)
MOVD $1814, R11
BR callbackasm1(SB)
MOVD $1815, R11
BR callbackasm1(SB)
MOVD $1816, R11
BR callbackasm1(SB)
MOVD $1817, R11
BR callbackasm1(SB)
MOVD $1818, R11
BR callbackasm1(SB)
MOVD $1819, R11
BR callbackasm1(SB)
MOVD $1820, R11
BR callbackasm1(SB)
MOVD $1821, R11
BR callbackasm1(SB)
MOVD $1822, R11
BR callbackasm1(SB)
MOVD $1823, R11
BR callbackasm1(SB)
MOVD $1824, R11
BR callbackasm1(SB)
MOVD $1825, R11
BR callbackasm1(SB)
MOVD $1826, R11
BR callbackasm1(SB)
MOVD $1827, R11
BR callbackasm1(SB)
MOVD $1828, R11
BR callbackasm1(SB)
MOVD $1829, R11
BR callbackasm1(SB)
MOVD $1830, R11
BR callbackasm1(SB)
MOVD $1831, R11
BR callbackasm1(SB)
MOVD $1832, R11
BR callbackasm1(SB)
MOVD $1833, R11
BR callbackasm1(SB)
MOVD $1834, R11
BR callbackasm1(SB)
MOVD $1835, R11
BR callbackasm1(SB)
MOVD $1836, R11
BR callbackasm1(SB)
MOVD $1837, R11
BR callbackasm1(SB)
MOVD $1838, R11
BR callbackasm1(SB)
MOVD $1839, R11
BR callbackasm1(SB)
MOVD $1840, R11
BR callbackasm1(SB)
MOVD $1841, R11
BR callbackasm1(SB)
MOVD $1842, R11
BR callbackasm1(SB)
MOVD $1843, R11
BR callbackasm1(SB)
MOVD $1844, R11
BR callbackasm1(SB)
MOVD $1845, R11
BR callbackasm1(SB)
MOVD $1846, R11
BR callbackasm1(SB)
MOVD $1847, R11
BR callbackasm1(SB)
MOVD $1848, R11
BR callbackasm1(SB)
MOVD $1849, R11
BR callbackasm1(SB)
MOVD $1850, R11
BR callbackasm1(SB)
MOVD $1851, R11
BR callbackasm1(SB)
MOVD $1852, R11
BR callbackasm1(SB)
MOVD $1853, R11
BR callbackasm1(SB)
MOVD $1854, R11
BR callbackasm1(SB)
MOVD $1855, R11
BR callbackasm1(SB)
MOVD $1856, R11
BR callbackasm1(SB)
MOVD $1857, R11
BR callbackasm1(SB)
MOVD $1858, R11
BR callbackasm1(SB)
MOVD $1859, R11
BR callbackasm1(SB)
MOVD $1860, R11
BR callbackasm1(SB)
MOVD $1861, R11
BR callbackasm1(SB)
MOVD $1862, R11
BR callbackasm1(SB)
MOVD $1863, R11
BR callbackasm1(SB)
MOVD $1864, R11
BR callbackasm1(SB)
MOVD $1865, R11
BR callbackasm1(SB)
MOVD $1866, R11
BR callbackasm1(SB)
MOVD $1867, R11
BR callbackasm1(SB)
MOVD $1868, R11
BR callbackasm1(SB)
MOVD $1869, R11
BR callbackasm1(SB)
MOVD $1870, R11
BR callbackasm1(SB)
MOVD $1871, R11
BR callbackasm1(SB)
MOVD $1872, R11
BR callbackasm1(SB)
MOVD $1873, R11
BR callbackasm1(SB)
MOVD $1874, R11
BR callbackasm1(SB)
MOVD $1875, R11
BR callbackasm1(SB)
MOVD $1876, R11
BR callbackasm1(SB)
MOVD $1877, R11
BR callbackasm1(SB)
MOVD $1878, R11
BR callbackasm1(SB)
MOVD $1879, R11
BR callbackasm1(SB)
MOVD $1880, R11
BR callbackasm1(SB)
MOVD $1881, R11
BR callbackasm1(SB)
MOVD $1882, R11
BR callbackasm1(SB)
MOVD $1883, R11
BR callbackasm1(SB)
MOVD $1884, R11
BR callbackasm1(SB)
MOVD $1885, R11
BR callbackasm1(SB)
MOVD $1886, R11
BR callbackasm1(SB)
MOVD $1887, R11
BR callbackasm1(SB)
MOVD $1888, R11
BR callbackasm1(SB)
MOVD $1889, R11
BR callbackasm1(SB)
MOVD $1890, R11
BR callbackasm1(SB)
MOVD $1891, R11
BR callbackasm1(SB)
MOVD $1892, R11
BR callbackasm1(SB)
MOVD $1893, R11
BR callbackasm1(SB)
MOVD $1894, R11
BR callbackasm1(SB)
MOVD $1895, R11
BR callbackasm1(SB)
MOVD $1896, R11
BR callbackasm1(SB)
MOVD $1897, R11
BR callbackasm1(SB)
MOVD $1898, R11
BR callbackasm1(SB)
MOVD $1899, R11
BR callbackasm1(SB)
MOVD $1900, R11
BR callbackasm1(SB)
MOVD $1901, R11
BR callbackasm1(SB)
MOVD $1902, R11
BR callbackasm1(SB)
MOVD $1903, R11
BR callbackasm1(SB)
MOVD $1904, R11
BR callbackasm1(SB)
MOVD $1905, R11
BR callbackasm1(SB)
MOVD $1906, R11
BR callbackasm1(SB)
MOVD $1907, R11
BR callbackasm1(SB)
MOVD $1908, R11
BR callbackasm1(SB)
MOVD $1909, R11
BR callbackasm1(SB)
MOVD $1910, R11
BR callbackasm1(SB)
MOVD $1911, R11
BR callbackasm1(SB)
MOVD $1912, R11
BR callbackasm1(SB)
MOVD $1913, R11
BR callbackasm1(SB)
MOVD $1914, R11
BR callbackasm1(SB)
MOVD $1915, R11
BR callbackasm1(SB)
MOVD $1916, R11
BR callbackasm1(SB)
MOVD $1917, R11
BR callbackasm1(SB)
MOVD $1918, R11
BR callbackasm1(SB)
MOVD $1919, R11
BR callbackasm1(SB)
MOVD $1920, R11
BR callbackasm1(SB)
MOVD $1921, R11
BR callbackasm1(SB)
MOVD $1922, R11
BR callbackasm1(SB)
MOVD $1923, R11
BR callbackasm1(SB)
MOVD $1924, R11
BR callbackasm1(SB)
MOVD $1925, R11
BR callbackasm1(SB)
MOVD $1926, R11
BR callbackasm1(SB)
MOVD $1927, R11
BR callbackasm1(SB)
MOVD $1928, R11
BR callbackasm1(SB)
MOVD $1929, R11
BR callbackasm1(SB)
MOVD $1930, R11
BR callbackasm1(SB)
MOVD $1931, R11
BR callbackasm1(SB)
MOVD $1932, R11
BR callbackasm1(SB)
MOVD $1933, R11
BR callbackasm1(SB)
MOVD $1934, R11
BR callbackasm1(SB)
MOVD $1935, R11
BR callbackasm1(SB)
MOVD $1936, R11
BR callbackasm1(SB)
MOVD $1937, R11
BR callbackasm1(SB)
MOVD $1938, R11
BR callbackasm1(SB)
MOVD $1939, R11
BR callbackasm1(SB)
MOVD $1940, R11
BR callbackasm1(SB)
MOVD $1941, R11
BR callbackasm1(SB)
MOVD $1942, R11
BR callbackasm1(SB)
MOVD $1943, R11
BR callbackasm1(SB)
MOVD $1944, R11
BR callbackasm1(SB)
MOVD $1945, R11
BR callbackasm1(SB)
MOVD $1946, R11
BR callbackasm1(SB)
MOVD $1947, R11
BR callbackasm1(SB)
MOVD $1948, R11
BR callbackasm1(SB)
MOVD $1949, R11
BR callbackasm1(SB)
MOVD $1950, R11
BR callbackasm1(SB)
MOVD $1951, R11
BR callbackasm1(SB)
MOVD $1952, R11
BR callbackasm1(SB)
MOVD $1953, R11
BR callbackasm1(SB)
MOVD $1954, R11
BR callbackasm1(SB)
MOVD $1955, R11
BR callbackasm1(SB)
MOVD $1956, R11
BR callbackasm1(SB)
MOVD $1957, R11
BR callbackasm1(SB)
MOVD $1958, R11
BR callbackasm1(SB)
MOVD $1959, R11
BR callbackasm1(SB)
MOVD $1960, R11
BR callbackasm1(SB)
MOVD $1961, R11
BR callbackasm1(SB)
MOVD $1962, R11
BR callbackasm1(SB)
MOVD $1963, R11
BR callbackasm1(SB)
MOVD $1964, R11
BR callbackasm1(SB)
MOVD $1965, R11
BR callbackasm1(SB)
MOVD $1966, R11
BR callbackasm1(SB)
MOVD $1967, R11
BR callbackasm1(SB)
MOVD $1968, R11
BR callbackasm1(SB)
MOVD $1969, R11
BR callbackasm1(SB)
MOVD $1970, R11
BR callbackasm1(SB)
MOVD $1971, R11
BR callbackasm1(SB)
MOVD $1972, R11
BR callbackasm1(SB)
MOVD $1973, R11
BR callbackasm1(SB)
MOVD $1974, R11
BR callbackasm1(SB)
MOVD $1975, R11
BR callbackasm1(SB)
MOVD $1976, R11
BR callbackasm1(SB)
MOVD $1977, R11
BR callbackasm1(SB)
MOVD $1978, R11
BR callbackasm1(SB)
MOVD $1979, R11
BR callbackasm1(SB)
MOVD $1980, R11
BR callbackasm1(SB)
MOVD $1981, R11
BR callbackasm1(SB)
MOVD $1982, R11
BR callbackasm1(SB)
MOVD $1983, R11
BR callbackasm1(SB)
MOVD $1984, R11
BR callbackasm1(SB)
MOVD $1985, R11
BR callbackasm1(SB)
MOVD $1986, R11
BR callbackasm1(SB)
MOVD $1987, R11
BR callbackasm1(SB)
MOVD $1988, R11
BR callbackasm1(SB)
MOVD $1989, R11
BR callbackasm1(SB)
MOVD $1990, R11
BR callbackasm1(SB)
MOVD $1991, R11
BR callbackasm1(SB)
MOVD $1992, R11
BR callbackasm1(SB)
MOVD $1993, R11
BR callbackasm1(SB)
MOVD $1994, R11
BR callbackasm1(SB)
MOVD $1995, R11
BR callbackasm1(SB)
MOVD $1996, R11
BR callbackasm1(SB)
MOVD $1997, R11
BR callbackasm1(SB)
MOVD $1998, R11
BR callbackasm1(SB)
MOVD $1999, R11
BR callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_riscv64.s 0000664 0000000 0000000 00000221420 15207302613 0023420 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build darwin || freebsd || linux || netbsd
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOV and JMP instructions.
// Since Go 1.26, MOV instructions with immediate values lower than or equal to 32
// are encoded in 2 bytes rather than 4 bytes, which breaks the assumption that each
// callback entry is 8 bytes long. Therefore, for callback indices less than or equal to 32,
// add a PCALIGN directive to align the next instruction to an 8-byte boundary.
// The MOV instruction loads X7 with the callback index, and the
// JMP instruction branches to callbackasm1.
// callbackasm1 takes the callback index from X7 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
PCALIGN $8
MOV $0, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $1, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $2, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $3, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $4, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $5, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $6, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $7, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $8, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $9, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $10, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $11, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $12, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $13, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $14, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $15, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $16, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $17, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $18, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $19, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $20, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $21, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $22, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $23, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $24, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $25, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $26, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $27, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $28, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $29, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $30, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $31, X7
JMP callbackasm1(SB)
PCALIGN $8
MOV $32, X7
JMP callbackasm1(SB)
MOV $33, X7
JMP callbackasm1(SB)
MOV $34, X7
JMP callbackasm1(SB)
MOV $35, X7
JMP callbackasm1(SB)
MOV $36, X7
JMP callbackasm1(SB)
MOV $37, X7
JMP callbackasm1(SB)
MOV $38, X7
JMP callbackasm1(SB)
MOV $39, X7
JMP callbackasm1(SB)
MOV $40, X7
JMP callbackasm1(SB)
MOV $41, X7
JMP callbackasm1(SB)
MOV $42, X7
JMP callbackasm1(SB)
MOV $43, X7
JMP callbackasm1(SB)
MOV $44, X7
JMP callbackasm1(SB)
MOV $45, X7
JMP callbackasm1(SB)
MOV $46, X7
JMP callbackasm1(SB)
MOV $47, X7
JMP callbackasm1(SB)
MOV $48, X7
JMP callbackasm1(SB)
MOV $49, X7
JMP callbackasm1(SB)
MOV $50, X7
JMP callbackasm1(SB)
MOV $51, X7
JMP callbackasm1(SB)
MOV $52, X7
JMP callbackasm1(SB)
MOV $53, X7
JMP callbackasm1(SB)
MOV $54, X7
JMP callbackasm1(SB)
MOV $55, X7
JMP callbackasm1(SB)
MOV $56, X7
JMP callbackasm1(SB)
MOV $57, X7
JMP callbackasm1(SB)
MOV $58, X7
JMP callbackasm1(SB)
MOV $59, X7
JMP callbackasm1(SB)
MOV $60, X7
JMP callbackasm1(SB)
MOV $61, X7
JMP callbackasm1(SB)
MOV $62, X7
JMP callbackasm1(SB)
MOV $63, X7
JMP callbackasm1(SB)
MOV $64, X7
JMP callbackasm1(SB)
MOV $65, X7
JMP callbackasm1(SB)
MOV $66, X7
JMP callbackasm1(SB)
MOV $67, X7
JMP callbackasm1(SB)
MOV $68, X7
JMP callbackasm1(SB)
MOV $69, X7
JMP callbackasm1(SB)
MOV $70, X7
JMP callbackasm1(SB)
MOV $71, X7
JMP callbackasm1(SB)
MOV $72, X7
JMP callbackasm1(SB)
MOV $73, X7
JMP callbackasm1(SB)
MOV $74, X7
JMP callbackasm1(SB)
MOV $75, X7
JMP callbackasm1(SB)
MOV $76, X7
JMP callbackasm1(SB)
MOV $77, X7
JMP callbackasm1(SB)
MOV $78, X7
JMP callbackasm1(SB)
MOV $79, X7
JMP callbackasm1(SB)
MOV $80, X7
JMP callbackasm1(SB)
MOV $81, X7
JMP callbackasm1(SB)
MOV $82, X7
JMP callbackasm1(SB)
MOV $83, X7
JMP callbackasm1(SB)
MOV $84, X7
JMP callbackasm1(SB)
MOV $85, X7
JMP callbackasm1(SB)
MOV $86, X7
JMP callbackasm1(SB)
MOV $87, X7
JMP callbackasm1(SB)
MOV $88, X7
JMP callbackasm1(SB)
MOV $89, X7
JMP callbackasm1(SB)
MOV $90, X7
JMP callbackasm1(SB)
MOV $91, X7
JMP callbackasm1(SB)
MOV $92, X7
JMP callbackasm1(SB)
MOV $93, X7
JMP callbackasm1(SB)
MOV $94, X7
JMP callbackasm1(SB)
MOV $95, X7
JMP callbackasm1(SB)
MOV $96, X7
JMP callbackasm1(SB)
MOV $97, X7
JMP callbackasm1(SB)
MOV $98, X7
JMP callbackasm1(SB)
MOV $99, X7
JMP callbackasm1(SB)
MOV $100, X7
JMP callbackasm1(SB)
MOV $101, X7
JMP callbackasm1(SB)
MOV $102, X7
JMP callbackasm1(SB)
MOV $103, X7
JMP callbackasm1(SB)
MOV $104, X7
JMP callbackasm1(SB)
MOV $105, X7
JMP callbackasm1(SB)
MOV $106, X7
JMP callbackasm1(SB)
MOV $107, X7
JMP callbackasm1(SB)
MOV $108, X7
JMP callbackasm1(SB)
MOV $109, X7
JMP callbackasm1(SB)
MOV $110, X7
JMP callbackasm1(SB)
MOV $111, X7
JMP callbackasm1(SB)
MOV $112, X7
JMP callbackasm1(SB)
MOV $113, X7
JMP callbackasm1(SB)
MOV $114, X7
JMP callbackasm1(SB)
MOV $115, X7
JMP callbackasm1(SB)
MOV $116, X7
JMP callbackasm1(SB)
MOV $117, X7
JMP callbackasm1(SB)
MOV $118, X7
JMP callbackasm1(SB)
MOV $119, X7
JMP callbackasm1(SB)
MOV $120, X7
JMP callbackasm1(SB)
MOV $121, X7
JMP callbackasm1(SB)
MOV $122, X7
JMP callbackasm1(SB)
MOV $123, X7
JMP callbackasm1(SB)
MOV $124, X7
JMP callbackasm1(SB)
MOV $125, X7
JMP callbackasm1(SB)
MOV $126, X7
JMP callbackasm1(SB)
MOV $127, X7
JMP callbackasm1(SB)
MOV $128, X7
JMP callbackasm1(SB)
MOV $129, X7
JMP callbackasm1(SB)
MOV $130, X7
JMP callbackasm1(SB)
MOV $131, X7
JMP callbackasm1(SB)
MOV $132, X7
JMP callbackasm1(SB)
MOV $133, X7
JMP callbackasm1(SB)
MOV $134, X7
JMP callbackasm1(SB)
MOV $135, X7
JMP callbackasm1(SB)
MOV $136, X7
JMP callbackasm1(SB)
MOV $137, X7
JMP callbackasm1(SB)
MOV $138, X7
JMP callbackasm1(SB)
MOV $139, X7
JMP callbackasm1(SB)
MOV $140, X7
JMP callbackasm1(SB)
MOV $141, X7
JMP callbackasm1(SB)
MOV $142, X7
JMP callbackasm1(SB)
MOV $143, X7
JMP callbackasm1(SB)
MOV $144, X7
JMP callbackasm1(SB)
MOV $145, X7
JMP callbackasm1(SB)
MOV $146, X7
JMP callbackasm1(SB)
MOV $147, X7
JMP callbackasm1(SB)
MOV $148, X7
JMP callbackasm1(SB)
MOV $149, X7
JMP callbackasm1(SB)
MOV $150, X7
JMP callbackasm1(SB)
MOV $151, X7
JMP callbackasm1(SB)
MOV $152, X7
JMP callbackasm1(SB)
MOV $153, X7
JMP callbackasm1(SB)
MOV $154, X7
JMP callbackasm1(SB)
MOV $155, X7
JMP callbackasm1(SB)
MOV $156, X7
JMP callbackasm1(SB)
MOV $157, X7
JMP callbackasm1(SB)
MOV $158, X7
JMP callbackasm1(SB)
MOV $159, X7
JMP callbackasm1(SB)
MOV $160, X7
JMP callbackasm1(SB)
MOV $161, X7
JMP callbackasm1(SB)
MOV $162, X7
JMP callbackasm1(SB)
MOV $163, X7
JMP callbackasm1(SB)
MOV $164, X7
JMP callbackasm1(SB)
MOV $165, X7
JMP callbackasm1(SB)
MOV $166, X7
JMP callbackasm1(SB)
MOV $167, X7
JMP callbackasm1(SB)
MOV $168, X7
JMP callbackasm1(SB)
MOV $169, X7
JMP callbackasm1(SB)
MOV $170, X7
JMP callbackasm1(SB)
MOV $171, X7
JMP callbackasm1(SB)
MOV $172, X7
JMP callbackasm1(SB)
MOV $173, X7
JMP callbackasm1(SB)
MOV $174, X7
JMP callbackasm1(SB)
MOV $175, X7
JMP callbackasm1(SB)
MOV $176, X7
JMP callbackasm1(SB)
MOV $177, X7
JMP callbackasm1(SB)
MOV $178, X7
JMP callbackasm1(SB)
MOV $179, X7
JMP callbackasm1(SB)
MOV $180, X7
JMP callbackasm1(SB)
MOV $181, X7
JMP callbackasm1(SB)
MOV $182, X7
JMP callbackasm1(SB)
MOV $183, X7
JMP callbackasm1(SB)
MOV $184, X7
JMP callbackasm1(SB)
MOV $185, X7
JMP callbackasm1(SB)
MOV $186, X7
JMP callbackasm1(SB)
MOV $187, X7
JMP callbackasm1(SB)
MOV $188, X7
JMP callbackasm1(SB)
MOV $189, X7
JMP callbackasm1(SB)
MOV $190, X7
JMP callbackasm1(SB)
MOV $191, X7
JMP callbackasm1(SB)
MOV $192, X7
JMP callbackasm1(SB)
MOV $193, X7
JMP callbackasm1(SB)
MOV $194, X7
JMP callbackasm1(SB)
MOV $195, X7
JMP callbackasm1(SB)
MOV $196, X7
JMP callbackasm1(SB)
MOV $197, X7
JMP callbackasm1(SB)
MOV $198, X7
JMP callbackasm1(SB)
MOV $199, X7
JMP callbackasm1(SB)
MOV $200, X7
JMP callbackasm1(SB)
MOV $201, X7
JMP callbackasm1(SB)
MOV $202, X7
JMP callbackasm1(SB)
MOV $203, X7
JMP callbackasm1(SB)
MOV $204, X7
JMP callbackasm1(SB)
MOV $205, X7
JMP callbackasm1(SB)
MOV $206, X7
JMP callbackasm1(SB)
MOV $207, X7
JMP callbackasm1(SB)
MOV $208, X7
JMP callbackasm1(SB)
MOV $209, X7
JMP callbackasm1(SB)
MOV $210, X7
JMP callbackasm1(SB)
MOV $211, X7
JMP callbackasm1(SB)
MOV $212, X7
JMP callbackasm1(SB)
MOV $213, X7
JMP callbackasm1(SB)
MOV $214, X7
JMP callbackasm1(SB)
MOV $215, X7
JMP callbackasm1(SB)
MOV $216, X7
JMP callbackasm1(SB)
MOV $217, X7
JMP callbackasm1(SB)
MOV $218, X7
JMP callbackasm1(SB)
MOV $219, X7
JMP callbackasm1(SB)
MOV $220, X7
JMP callbackasm1(SB)
MOV $221, X7
JMP callbackasm1(SB)
MOV $222, X7
JMP callbackasm1(SB)
MOV $223, X7
JMP callbackasm1(SB)
MOV $224, X7
JMP callbackasm1(SB)
MOV $225, X7
JMP callbackasm1(SB)
MOV $226, X7
JMP callbackasm1(SB)
MOV $227, X7
JMP callbackasm1(SB)
MOV $228, X7
JMP callbackasm1(SB)
MOV $229, X7
JMP callbackasm1(SB)
MOV $230, X7
JMP callbackasm1(SB)
MOV $231, X7
JMP callbackasm1(SB)
MOV $232, X7
JMP callbackasm1(SB)
MOV $233, X7
JMP callbackasm1(SB)
MOV $234, X7
JMP callbackasm1(SB)
MOV $235, X7
JMP callbackasm1(SB)
MOV $236, X7
JMP callbackasm1(SB)
MOV $237, X7
JMP callbackasm1(SB)
MOV $238, X7
JMP callbackasm1(SB)
MOV $239, X7
JMP callbackasm1(SB)
MOV $240, X7
JMP callbackasm1(SB)
MOV $241, X7
JMP callbackasm1(SB)
MOV $242, X7
JMP callbackasm1(SB)
MOV $243, X7
JMP callbackasm1(SB)
MOV $244, X7
JMP callbackasm1(SB)
MOV $245, X7
JMP callbackasm1(SB)
MOV $246, X7
JMP callbackasm1(SB)
MOV $247, X7
JMP callbackasm1(SB)
MOV $248, X7
JMP callbackasm1(SB)
MOV $249, X7
JMP callbackasm1(SB)
MOV $250, X7
JMP callbackasm1(SB)
MOV $251, X7
JMP callbackasm1(SB)
MOV $252, X7
JMP callbackasm1(SB)
MOV $253, X7
JMP callbackasm1(SB)
MOV $254, X7
JMP callbackasm1(SB)
MOV $255, X7
JMP callbackasm1(SB)
MOV $256, X7
JMP callbackasm1(SB)
MOV $257, X7
JMP callbackasm1(SB)
MOV $258, X7
JMP callbackasm1(SB)
MOV $259, X7
JMP callbackasm1(SB)
MOV $260, X7
JMP callbackasm1(SB)
MOV $261, X7
JMP callbackasm1(SB)
MOV $262, X7
JMP callbackasm1(SB)
MOV $263, X7
JMP callbackasm1(SB)
MOV $264, X7
JMP callbackasm1(SB)
MOV $265, X7
JMP callbackasm1(SB)
MOV $266, X7
JMP callbackasm1(SB)
MOV $267, X7
JMP callbackasm1(SB)
MOV $268, X7
JMP callbackasm1(SB)
MOV $269, X7
JMP callbackasm1(SB)
MOV $270, X7
JMP callbackasm1(SB)
MOV $271, X7
JMP callbackasm1(SB)
MOV $272, X7
JMP callbackasm1(SB)
MOV $273, X7
JMP callbackasm1(SB)
MOV $274, X7
JMP callbackasm1(SB)
MOV $275, X7
JMP callbackasm1(SB)
MOV $276, X7
JMP callbackasm1(SB)
MOV $277, X7
JMP callbackasm1(SB)
MOV $278, X7
JMP callbackasm1(SB)
MOV $279, X7
JMP callbackasm1(SB)
MOV $280, X7
JMP callbackasm1(SB)
MOV $281, X7
JMP callbackasm1(SB)
MOV $282, X7
JMP callbackasm1(SB)
MOV $283, X7
JMP callbackasm1(SB)
MOV $284, X7
JMP callbackasm1(SB)
MOV $285, X7
JMP callbackasm1(SB)
MOV $286, X7
JMP callbackasm1(SB)
MOV $287, X7
JMP callbackasm1(SB)
MOV $288, X7
JMP callbackasm1(SB)
MOV $289, X7
JMP callbackasm1(SB)
MOV $290, X7
JMP callbackasm1(SB)
MOV $291, X7
JMP callbackasm1(SB)
MOV $292, X7
JMP callbackasm1(SB)
MOV $293, X7
JMP callbackasm1(SB)
MOV $294, X7
JMP callbackasm1(SB)
MOV $295, X7
JMP callbackasm1(SB)
MOV $296, X7
JMP callbackasm1(SB)
MOV $297, X7
JMP callbackasm1(SB)
MOV $298, X7
JMP callbackasm1(SB)
MOV $299, X7
JMP callbackasm1(SB)
MOV $300, X7
JMP callbackasm1(SB)
MOV $301, X7
JMP callbackasm1(SB)
MOV $302, X7
JMP callbackasm1(SB)
MOV $303, X7
JMP callbackasm1(SB)
MOV $304, X7
JMP callbackasm1(SB)
MOV $305, X7
JMP callbackasm1(SB)
MOV $306, X7
JMP callbackasm1(SB)
MOV $307, X7
JMP callbackasm1(SB)
MOV $308, X7
JMP callbackasm1(SB)
MOV $309, X7
JMP callbackasm1(SB)
MOV $310, X7
JMP callbackasm1(SB)
MOV $311, X7
JMP callbackasm1(SB)
MOV $312, X7
JMP callbackasm1(SB)
MOV $313, X7
JMP callbackasm1(SB)
MOV $314, X7
JMP callbackasm1(SB)
MOV $315, X7
JMP callbackasm1(SB)
MOV $316, X7
JMP callbackasm1(SB)
MOV $317, X7
JMP callbackasm1(SB)
MOV $318, X7
JMP callbackasm1(SB)
MOV $319, X7
JMP callbackasm1(SB)
MOV $320, X7
JMP callbackasm1(SB)
MOV $321, X7
JMP callbackasm1(SB)
MOV $322, X7
JMP callbackasm1(SB)
MOV $323, X7
JMP callbackasm1(SB)
MOV $324, X7
JMP callbackasm1(SB)
MOV $325, X7
JMP callbackasm1(SB)
MOV $326, X7
JMP callbackasm1(SB)
MOV $327, X7
JMP callbackasm1(SB)
MOV $328, X7
JMP callbackasm1(SB)
MOV $329, X7
JMP callbackasm1(SB)
MOV $330, X7
JMP callbackasm1(SB)
MOV $331, X7
JMP callbackasm1(SB)
MOV $332, X7
JMP callbackasm1(SB)
MOV $333, X7
JMP callbackasm1(SB)
MOV $334, X7
JMP callbackasm1(SB)
MOV $335, X7
JMP callbackasm1(SB)
MOV $336, X7
JMP callbackasm1(SB)
MOV $337, X7
JMP callbackasm1(SB)
MOV $338, X7
JMP callbackasm1(SB)
MOV $339, X7
JMP callbackasm1(SB)
MOV $340, X7
JMP callbackasm1(SB)
MOV $341, X7
JMP callbackasm1(SB)
MOV $342, X7
JMP callbackasm1(SB)
MOV $343, X7
JMP callbackasm1(SB)
MOV $344, X7
JMP callbackasm1(SB)
MOV $345, X7
JMP callbackasm1(SB)
MOV $346, X7
JMP callbackasm1(SB)
MOV $347, X7
JMP callbackasm1(SB)
MOV $348, X7
JMP callbackasm1(SB)
MOV $349, X7
JMP callbackasm1(SB)
MOV $350, X7
JMP callbackasm1(SB)
MOV $351, X7
JMP callbackasm1(SB)
MOV $352, X7
JMP callbackasm1(SB)
MOV $353, X7
JMP callbackasm1(SB)
MOV $354, X7
JMP callbackasm1(SB)
MOV $355, X7
JMP callbackasm1(SB)
MOV $356, X7
JMP callbackasm1(SB)
MOV $357, X7
JMP callbackasm1(SB)
MOV $358, X7
JMP callbackasm1(SB)
MOV $359, X7
JMP callbackasm1(SB)
MOV $360, X7
JMP callbackasm1(SB)
MOV $361, X7
JMP callbackasm1(SB)
MOV $362, X7
JMP callbackasm1(SB)
MOV $363, X7
JMP callbackasm1(SB)
MOV $364, X7
JMP callbackasm1(SB)
MOV $365, X7
JMP callbackasm1(SB)
MOV $366, X7
JMP callbackasm1(SB)
MOV $367, X7
JMP callbackasm1(SB)
MOV $368, X7
JMP callbackasm1(SB)
MOV $369, X7
JMP callbackasm1(SB)
MOV $370, X7
JMP callbackasm1(SB)
MOV $371, X7
JMP callbackasm1(SB)
MOV $372, X7
JMP callbackasm1(SB)
MOV $373, X7
JMP callbackasm1(SB)
MOV $374, X7
JMP callbackasm1(SB)
MOV $375, X7
JMP callbackasm1(SB)
MOV $376, X7
JMP callbackasm1(SB)
MOV $377, X7
JMP callbackasm1(SB)
MOV $378, X7
JMP callbackasm1(SB)
MOV $379, X7
JMP callbackasm1(SB)
MOV $380, X7
JMP callbackasm1(SB)
MOV $381, X7
JMP callbackasm1(SB)
MOV $382, X7
JMP callbackasm1(SB)
MOV $383, X7
JMP callbackasm1(SB)
MOV $384, X7
JMP callbackasm1(SB)
MOV $385, X7
JMP callbackasm1(SB)
MOV $386, X7
JMP callbackasm1(SB)
MOV $387, X7
JMP callbackasm1(SB)
MOV $388, X7
JMP callbackasm1(SB)
MOV $389, X7
JMP callbackasm1(SB)
MOV $390, X7
JMP callbackasm1(SB)
MOV $391, X7
JMP callbackasm1(SB)
MOV $392, X7
JMP callbackasm1(SB)
MOV $393, X7
JMP callbackasm1(SB)
MOV $394, X7
JMP callbackasm1(SB)
MOV $395, X7
JMP callbackasm1(SB)
MOV $396, X7
JMP callbackasm1(SB)
MOV $397, X7
JMP callbackasm1(SB)
MOV $398, X7
JMP callbackasm1(SB)
MOV $399, X7
JMP callbackasm1(SB)
MOV $400, X7
JMP callbackasm1(SB)
MOV $401, X7
JMP callbackasm1(SB)
MOV $402, X7
JMP callbackasm1(SB)
MOV $403, X7
JMP callbackasm1(SB)
MOV $404, X7
JMP callbackasm1(SB)
MOV $405, X7
JMP callbackasm1(SB)
MOV $406, X7
JMP callbackasm1(SB)
MOV $407, X7
JMP callbackasm1(SB)
MOV $408, X7
JMP callbackasm1(SB)
MOV $409, X7
JMP callbackasm1(SB)
MOV $410, X7
JMP callbackasm1(SB)
MOV $411, X7
JMP callbackasm1(SB)
MOV $412, X7
JMP callbackasm1(SB)
MOV $413, X7
JMP callbackasm1(SB)
MOV $414, X7
JMP callbackasm1(SB)
MOV $415, X7
JMP callbackasm1(SB)
MOV $416, X7
JMP callbackasm1(SB)
MOV $417, X7
JMP callbackasm1(SB)
MOV $418, X7
JMP callbackasm1(SB)
MOV $419, X7
JMP callbackasm1(SB)
MOV $420, X7
JMP callbackasm1(SB)
MOV $421, X7
JMP callbackasm1(SB)
MOV $422, X7
JMP callbackasm1(SB)
MOV $423, X7
JMP callbackasm1(SB)
MOV $424, X7
JMP callbackasm1(SB)
MOV $425, X7
JMP callbackasm1(SB)
MOV $426, X7
JMP callbackasm1(SB)
MOV $427, X7
JMP callbackasm1(SB)
MOV $428, X7
JMP callbackasm1(SB)
MOV $429, X7
JMP callbackasm1(SB)
MOV $430, X7
JMP callbackasm1(SB)
MOV $431, X7
JMP callbackasm1(SB)
MOV $432, X7
JMP callbackasm1(SB)
MOV $433, X7
JMP callbackasm1(SB)
MOV $434, X7
JMP callbackasm1(SB)
MOV $435, X7
JMP callbackasm1(SB)
MOV $436, X7
JMP callbackasm1(SB)
MOV $437, X7
JMP callbackasm1(SB)
MOV $438, X7
JMP callbackasm1(SB)
MOV $439, X7
JMP callbackasm1(SB)
MOV $440, X7
JMP callbackasm1(SB)
MOV $441, X7
JMP callbackasm1(SB)
MOV $442, X7
JMP callbackasm1(SB)
MOV $443, X7
JMP callbackasm1(SB)
MOV $444, X7
JMP callbackasm1(SB)
MOV $445, X7
JMP callbackasm1(SB)
MOV $446, X7
JMP callbackasm1(SB)
MOV $447, X7
JMP callbackasm1(SB)
MOV $448, X7
JMP callbackasm1(SB)
MOV $449, X7
JMP callbackasm1(SB)
MOV $450, X7
JMP callbackasm1(SB)
MOV $451, X7
JMP callbackasm1(SB)
MOV $452, X7
JMP callbackasm1(SB)
MOV $453, X7
JMP callbackasm1(SB)
MOV $454, X7
JMP callbackasm1(SB)
MOV $455, X7
JMP callbackasm1(SB)
MOV $456, X7
JMP callbackasm1(SB)
MOV $457, X7
JMP callbackasm1(SB)
MOV $458, X7
JMP callbackasm1(SB)
MOV $459, X7
JMP callbackasm1(SB)
MOV $460, X7
JMP callbackasm1(SB)
MOV $461, X7
JMP callbackasm1(SB)
MOV $462, X7
JMP callbackasm1(SB)
MOV $463, X7
JMP callbackasm1(SB)
MOV $464, X7
JMP callbackasm1(SB)
MOV $465, X7
JMP callbackasm1(SB)
MOV $466, X7
JMP callbackasm1(SB)
MOV $467, X7
JMP callbackasm1(SB)
MOV $468, X7
JMP callbackasm1(SB)
MOV $469, X7
JMP callbackasm1(SB)
MOV $470, X7
JMP callbackasm1(SB)
MOV $471, X7
JMP callbackasm1(SB)
MOV $472, X7
JMP callbackasm1(SB)
MOV $473, X7
JMP callbackasm1(SB)
MOV $474, X7
JMP callbackasm1(SB)
MOV $475, X7
JMP callbackasm1(SB)
MOV $476, X7
JMP callbackasm1(SB)
MOV $477, X7
JMP callbackasm1(SB)
MOV $478, X7
JMP callbackasm1(SB)
MOV $479, X7
JMP callbackasm1(SB)
MOV $480, X7
JMP callbackasm1(SB)
MOV $481, X7
JMP callbackasm1(SB)
MOV $482, X7
JMP callbackasm1(SB)
MOV $483, X7
JMP callbackasm1(SB)
MOV $484, X7
JMP callbackasm1(SB)
MOV $485, X7
JMP callbackasm1(SB)
MOV $486, X7
JMP callbackasm1(SB)
MOV $487, X7
JMP callbackasm1(SB)
MOV $488, X7
JMP callbackasm1(SB)
MOV $489, X7
JMP callbackasm1(SB)
MOV $490, X7
JMP callbackasm1(SB)
MOV $491, X7
JMP callbackasm1(SB)
MOV $492, X7
JMP callbackasm1(SB)
MOV $493, X7
JMP callbackasm1(SB)
MOV $494, X7
JMP callbackasm1(SB)
MOV $495, X7
JMP callbackasm1(SB)
MOV $496, X7
JMP callbackasm1(SB)
MOV $497, X7
JMP callbackasm1(SB)
MOV $498, X7
JMP callbackasm1(SB)
MOV $499, X7
JMP callbackasm1(SB)
MOV $500, X7
JMP callbackasm1(SB)
MOV $501, X7
JMP callbackasm1(SB)
MOV $502, X7
JMP callbackasm1(SB)
MOV $503, X7
JMP callbackasm1(SB)
MOV $504, X7
JMP callbackasm1(SB)
MOV $505, X7
JMP callbackasm1(SB)
MOV $506, X7
JMP callbackasm1(SB)
MOV $507, X7
JMP callbackasm1(SB)
MOV $508, X7
JMP callbackasm1(SB)
MOV $509, X7
JMP callbackasm1(SB)
MOV $510, X7
JMP callbackasm1(SB)
MOV $511, X7
JMP callbackasm1(SB)
MOV $512, X7
JMP callbackasm1(SB)
MOV $513, X7
JMP callbackasm1(SB)
MOV $514, X7
JMP callbackasm1(SB)
MOV $515, X7
JMP callbackasm1(SB)
MOV $516, X7
JMP callbackasm1(SB)
MOV $517, X7
JMP callbackasm1(SB)
MOV $518, X7
JMP callbackasm1(SB)
MOV $519, X7
JMP callbackasm1(SB)
MOV $520, X7
JMP callbackasm1(SB)
MOV $521, X7
JMP callbackasm1(SB)
MOV $522, X7
JMP callbackasm1(SB)
MOV $523, X7
JMP callbackasm1(SB)
MOV $524, X7
JMP callbackasm1(SB)
MOV $525, X7
JMP callbackasm1(SB)
MOV $526, X7
JMP callbackasm1(SB)
MOV $527, X7
JMP callbackasm1(SB)
MOV $528, X7
JMP callbackasm1(SB)
MOV $529, X7
JMP callbackasm1(SB)
MOV $530, X7
JMP callbackasm1(SB)
MOV $531, X7
JMP callbackasm1(SB)
MOV $532, X7
JMP callbackasm1(SB)
MOV $533, X7
JMP callbackasm1(SB)
MOV $534, X7
JMP callbackasm1(SB)
MOV $535, X7
JMP callbackasm1(SB)
MOV $536, X7
JMP callbackasm1(SB)
MOV $537, X7
JMP callbackasm1(SB)
MOV $538, X7
JMP callbackasm1(SB)
MOV $539, X7
JMP callbackasm1(SB)
MOV $540, X7
JMP callbackasm1(SB)
MOV $541, X7
JMP callbackasm1(SB)
MOV $542, X7
JMP callbackasm1(SB)
MOV $543, X7
JMP callbackasm1(SB)
MOV $544, X7
JMP callbackasm1(SB)
MOV $545, X7
JMP callbackasm1(SB)
MOV $546, X7
JMP callbackasm1(SB)
MOV $547, X7
JMP callbackasm1(SB)
MOV $548, X7
JMP callbackasm1(SB)
MOV $549, X7
JMP callbackasm1(SB)
MOV $550, X7
JMP callbackasm1(SB)
MOV $551, X7
JMP callbackasm1(SB)
MOV $552, X7
JMP callbackasm1(SB)
MOV $553, X7
JMP callbackasm1(SB)
MOV $554, X7
JMP callbackasm1(SB)
MOV $555, X7
JMP callbackasm1(SB)
MOV $556, X7
JMP callbackasm1(SB)
MOV $557, X7
JMP callbackasm1(SB)
MOV $558, X7
JMP callbackasm1(SB)
MOV $559, X7
JMP callbackasm1(SB)
MOV $560, X7
JMP callbackasm1(SB)
MOV $561, X7
JMP callbackasm1(SB)
MOV $562, X7
JMP callbackasm1(SB)
MOV $563, X7
JMP callbackasm1(SB)
MOV $564, X7
JMP callbackasm1(SB)
MOV $565, X7
JMP callbackasm1(SB)
MOV $566, X7
JMP callbackasm1(SB)
MOV $567, X7
JMP callbackasm1(SB)
MOV $568, X7
JMP callbackasm1(SB)
MOV $569, X7
JMP callbackasm1(SB)
MOV $570, X7
JMP callbackasm1(SB)
MOV $571, X7
JMP callbackasm1(SB)
MOV $572, X7
JMP callbackasm1(SB)
MOV $573, X7
JMP callbackasm1(SB)
MOV $574, X7
JMP callbackasm1(SB)
MOV $575, X7
JMP callbackasm1(SB)
MOV $576, X7
JMP callbackasm1(SB)
MOV $577, X7
JMP callbackasm1(SB)
MOV $578, X7
JMP callbackasm1(SB)
MOV $579, X7
JMP callbackasm1(SB)
MOV $580, X7
JMP callbackasm1(SB)
MOV $581, X7
JMP callbackasm1(SB)
MOV $582, X7
JMP callbackasm1(SB)
MOV $583, X7
JMP callbackasm1(SB)
MOV $584, X7
JMP callbackasm1(SB)
MOV $585, X7
JMP callbackasm1(SB)
MOV $586, X7
JMP callbackasm1(SB)
MOV $587, X7
JMP callbackasm1(SB)
MOV $588, X7
JMP callbackasm1(SB)
MOV $589, X7
JMP callbackasm1(SB)
MOV $590, X7
JMP callbackasm1(SB)
MOV $591, X7
JMP callbackasm1(SB)
MOV $592, X7
JMP callbackasm1(SB)
MOV $593, X7
JMP callbackasm1(SB)
MOV $594, X7
JMP callbackasm1(SB)
MOV $595, X7
JMP callbackasm1(SB)
MOV $596, X7
JMP callbackasm1(SB)
MOV $597, X7
JMP callbackasm1(SB)
MOV $598, X7
JMP callbackasm1(SB)
MOV $599, X7
JMP callbackasm1(SB)
MOV $600, X7
JMP callbackasm1(SB)
MOV $601, X7
JMP callbackasm1(SB)
MOV $602, X7
JMP callbackasm1(SB)
MOV $603, X7
JMP callbackasm1(SB)
MOV $604, X7
JMP callbackasm1(SB)
MOV $605, X7
JMP callbackasm1(SB)
MOV $606, X7
JMP callbackasm1(SB)
MOV $607, X7
JMP callbackasm1(SB)
MOV $608, X7
JMP callbackasm1(SB)
MOV $609, X7
JMP callbackasm1(SB)
MOV $610, X7
JMP callbackasm1(SB)
MOV $611, X7
JMP callbackasm1(SB)
MOV $612, X7
JMP callbackasm1(SB)
MOV $613, X7
JMP callbackasm1(SB)
MOV $614, X7
JMP callbackasm1(SB)
MOV $615, X7
JMP callbackasm1(SB)
MOV $616, X7
JMP callbackasm1(SB)
MOV $617, X7
JMP callbackasm1(SB)
MOV $618, X7
JMP callbackasm1(SB)
MOV $619, X7
JMP callbackasm1(SB)
MOV $620, X7
JMP callbackasm1(SB)
MOV $621, X7
JMP callbackasm1(SB)
MOV $622, X7
JMP callbackasm1(SB)
MOV $623, X7
JMP callbackasm1(SB)
MOV $624, X7
JMP callbackasm1(SB)
MOV $625, X7
JMP callbackasm1(SB)
MOV $626, X7
JMP callbackasm1(SB)
MOV $627, X7
JMP callbackasm1(SB)
MOV $628, X7
JMP callbackasm1(SB)
MOV $629, X7
JMP callbackasm1(SB)
MOV $630, X7
JMP callbackasm1(SB)
MOV $631, X7
JMP callbackasm1(SB)
MOV $632, X7
JMP callbackasm1(SB)
MOV $633, X7
JMP callbackasm1(SB)
MOV $634, X7
JMP callbackasm1(SB)
MOV $635, X7
JMP callbackasm1(SB)
MOV $636, X7
JMP callbackasm1(SB)
MOV $637, X7
JMP callbackasm1(SB)
MOV $638, X7
JMP callbackasm1(SB)
MOV $639, X7
JMP callbackasm1(SB)
MOV $640, X7
JMP callbackasm1(SB)
MOV $641, X7
JMP callbackasm1(SB)
MOV $642, X7
JMP callbackasm1(SB)
MOV $643, X7
JMP callbackasm1(SB)
MOV $644, X7
JMP callbackasm1(SB)
MOV $645, X7
JMP callbackasm1(SB)
MOV $646, X7
JMP callbackasm1(SB)
MOV $647, X7
JMP callbackasm1(SB)
MOV $648, X7
JMP callbackasm1(SB)
MOV $649, X7
JMP callbackasm1(SB)
MOV $650, X7
JMP callbackasm1(SB)
MOV $651, X7
JMP callbackasm1(SB)
MOV $652, X7
JMP callbackasm1(SB)
MOV $653, X7
JMP callbackasm1(SB)
MOV $654, X7
JMP callbackasm1(SB)
MOV $655, X7
JMP callbackasm1(SB)
MOV $656, X7
JMP callbackasm1(SB)
MOV $657, X7
JMP callbackasm1(SB)
MOV $658, X7
JMP callbackasm1(SB)
MOV $659, X7
JMP callbackasm1(SB)
MOV $660, X7
JMP callbackasm1(SB)
MOV $661, X7
JMP callbackasm1(SB)
MOV $662, X7
JMP callbackasm1(SB)
MOV $663, X7
JMP callbackasm1(SB)
MOV $664, X7
JMP callbackasm1(SB)
MOV $665, X7
JMP callbackasm1(SB)
MOV $666, X7
JMP callbackasm1(SB)
MOV $667, X7
JMP callbackasm1(SB)
MOV $668, X7
JMP callbackasm1(SB)
MOV $669, X7
JMP callbackasm1(SB)
MOV $670, X7
JMP callbackasm1(SB)
MOV $671, X7
JMP callbackasm1(SB)
MOV $672, X7
JMP callbackasm1(SB)
MOV $673, X7
JMP callbackasm1(SB)
MOV $674, X7
JMP callbackasm1(SB)
MOV $675, X7
JMP callbackasm1(SB)
MOV $676, X7
JMP callbackasm1(SB)
MOV $677, X7
JMP callbackasm1(SB)
MOV $678, X7
JMP callbackasm1(SB)
MOV $679, X7
JMP callbackasm1(SB)
MOV $680, X7
JMP callbackasm1(SB)
MOV $681, X7
JMP callbackasm1(SB)
MOV $682, X7
JMP callbackasm1(SB)
MOV $683, X7
JMP callbackasm1(SB)
MOV $684, X7
JMP callbackasm1(SB)
MOV $685, X7
JMP callbackasm1(SB)
MOV $686, X7
JMP callbackasm1(SB)
MOV $687, X7
JMP callbackasm1(SB)
MOV $688, X7
JMP callbackasm1(SB)
MOV $689, X7
JMP callbackasm1(SB)
MOV $690, X7
JMP callbackasm1(SB)
MOV $691, X7
JMP callbackasm1(SB)
MOV $692, X7
JMP callbackasm1(SB)
MOV $693, X7
JMP callbackasm1(SB)
MOV $694, X7
JMP callbackasm1(SB)
MOV $695, X7
JMP callbackasm1(SB)
MOV $696, X7
JMP callbackasm1(SB)
MOV $697, X7
JMP callbackasm1(SB)
MOV $698, X7
JMP callbackasm1(SB)
MOV $699, X7
JMP callbackasm1(SB)
MOV $700, X7
JMP callbackasm1(SB)
MOV $701, X7
JMP callbackasm1(SB)
MOV $702, X7
JMP callbackasm1(SB)
MOV $703, X7
JMP callbackasm1(SB)
MOV $704, X7
JMP callbackasm1(SB)
MOV $705, X7
JMP callbackasm1(SB)
MOV $706, X7
JMP callbackasm1(SB)
MOV $707, X7
JMP callbackasm1(SB)
MOV $708, X7
JMP callbackasm1(SB)
MOV $709, X7
JMP callbackasm1(SB)
MOV $710, X7
JMP callbackasm1(SB)
MOV $711, X7
JMP callbackasm1(SB)
MOV $712, X7
JMP callbackasm1(SB)
MOV $713, X7
JMP callbackasm1(SB)
MOV $714, X7
JMP callbackasm1(SB)
MOV $715, X7
JMP callbackasm1(SB)
MOV $716, X7
JMP callbackasm1(SB)
MOV $717, X7
JMP callbackasm1(SB)
MOV $718, X7
JMP callbackasm1(SB)
MOV $719, X7
JMP callbackasm1(SB)
MOV $720, X7
JMP callbackasm1(SB)
MOV $721, X7
JMP callbackasm1(SB)
MOV $722, X7
JMP callbackasm1(SB)
MOV $723, X7
JMP callbackasm1(SB)
MOV $724, X7
JMP callbackasm1(SB)
MOV $725, X7
JMP callbackasm1(SB)
MOV $726, X7
JMP callbackasm1(SB)
MOV $727, X7
JMP callbackasm1(SB)
MOV $728, X7
JMP callbackasm1(SB)
MOV $729, X7
JMP callbackasm1(SB)
MOV $730, X7
JMP callbackasm1(SB)
MOV $731, X7
JMP callbackasm1(SB)
MOV $732, X7
JMP callbackasm1(SB)
MOV $733, X7
JMP callbackasm1(SB)
MOV $734, X7
JMP callbackasm1(SB)
MOV $735, X7
JMP callbackasm1(SB)
MOV $736, X7
JMP callbackasm1(SB)
MOV $737, X7
JMP callbackasm1(SB)
MOV $738, X7
JMP callbackasm1(SB)
MOV $739, X7
JMP callbackasm1(SB)
MOV $740, X7
JMP callbackasm1(SB)
MOV $741, X7
JMP callbackasm1(SB)
MOV $742, X7
JMP callbackasm1(SB)
MOV $743, X7
JMP callbackasm1(SB)
MOV $744, X7
JMP callbackasm1(SB)
MOV $745, X7
JMP callbackasm1(SB)
MOV $746, X7
JMP callbackasm1(SB)
MOV $747, X7
JMP callbackasm1(SB)
MOV $748, X7
JMP callbackasm1(SB)
MOV $749, X7
JMP callbackasm1(SB)
MOV $750, X7
JMP callbackasm1(SB)
MOV $751, X7
JMP callbackasm1(SB)
MOV $752, X7
JMP callbackasm1(SB)
MOV $753, X7
JMP callbackasm1(SB)
MOV $754, X7
JMP callbackasm1(SB)
MOV $755, X7
JMP callbackasm1(SB)
MOV $756, X7
JMP callbackasm1(SB)
MOV $757, X7
JMP callbackasm1(SB)
MOV $758, X7
JMP callbackasm1(SB)
MOV $759, X7
JMP callbackasm1(SB)
MOV $760, X7
JMP callbackasm1(SB)
MOV $761, X7
JMP callbackasm1(SB)
MOV $762, X7
JMP callbackasm1(SB)
MOV $763, X7
JMP callbackasm1(SB)
MOV $764, X7
JMP callbackasm1(SB)
MOV $765, X7
JMP callbackasm1(SB)
MOV $766, X7
JMP callbackasm1(SB)
MOV $767, X7
JMP callbackasm1(SB)
MOV $768, X7
JMP callbackasm1(SB)
MOV $769, X7
JMP callbackasm1(SB)
MOV $770, X7
JMP callbackasm1(SB)
MOV $771, X7
JMP callbackasm1(SB)
MOV $772, X7
JMP callbackasm1(SB)
MOV $773, X7
JMP callbackasm1(SB)
MOV $774, X7
JMP callbackasm1(SB)
MOV $775, X7
JMP callbackasm1(SB)
MOV $776, X7
JMP callbackasm1(SB)
MOV $777, X7
JMP callbackasm1(SB)
MOV $778, X7
JMP callbackasm1(SB)
MOV $779, X7
JMP callbackasm1(SB)
MOV $780, X7
JMP callbackasm1(SB)
MOV $781, X7
JMP callbackasm1(SB)
MOV $782, X7
JMP callbackasm1(SB)
MOV $783, X7
JMP callbackasm1(SB)
MOV $784, X7
JMP callbackasm1(SB)
MOV $785, X7
JMP callbackasm1(SB)
MOV $786, X7
JMP callbackasm1(SB)
MOV $787, X7
JMP callbackasm1(SB)
MOV $788, X7
JMP callbackasm1(SB)
MOV $789, X7
JMP callbackasm1(SB)
MOV $790, X7
JMP callbackasm1(SB)
MOV $791, X7
JMP callbackasm1(SB)
MOV $792, X7
JMP callbackasm1(SB)
MOV $793, X7
JMP callbackasm1(SB)
MOV $794, X7
JMP callbackasm1(SB)
MOV $795, X7
JMP callbackasm1(SB)
MOV $796, X7
JMP callbackasm1(SB)
MOV $797, X7
JMP callbackasm1(SB)
MOV $798, X7
JMP callbackasm1(SB)
MOV $799, X7
JMP callbackasm1(SB)
MOV $800, X7
JMP callbackasm1(SB)
MOV $801, X7
JMP callbackasm1(SB)
MOV $802, X7
JMP callbackasm1(SB)
MOV $803, X7
JMP callbackasm1(SB)
MOV $804, X7
JMP callbackasm1(SB)
MOV $805, X7
JMP callbackasm1(SB)
MOV $806, X7
JMP callbackasm1(SB)
MOV $807, X7
JMP callbackasm1(SB)
MOV $808, X7
JMP callbackasm1(SB)
MOV $809, X7
JMP callbackasm1(SB)
MOV $810, X7
JMP callbackasm1(SB)
MOV $811, X7
JMP callbackasm1(SB)
MOV $812, X7
JMP callbackasm1(SB)
MOV $813, X7
JMP callbackasm1(SB)
MOV $814, X7
JMP callbackasm1(SB)
MOV $815, X7
JMP callbackasm1(SB)
MOV $816, X7
JMP callbackasm1(SB)
MOV $817, X7
JMP callbackasm1(SB)
MOV $818, X7
JMP callbackasm1(SB)
MOV $819, X7
JMP callbackasm1(SB)
MOV $820, X7
JMP callbackasm1(SB)
MOV $821, X7
JMP callbackasm1(SB)
MOV $822, X7
JMP callbackasm1(SB)
MOV $823, X7
JMP callbackasm1(SB)
MOV $824, X7
JMP callbackasm1(SB)
MOV $825, X7
JMP callbackasm1(SB)
MOV $826, X7
JMP callbackasm1(SB)
MOV $827, X7
JMP callbackasm1(SB)
MOV $828, X7
JMP callbackasm1(SB)
MOV $829, X7
JMP callbackasm1(SB)
MOV $830, X7
JMP callbackasm1(SB)
MOV $831, X7
JMP callbackasm1(SB)
MOV $832, X7
JMP callbackasm1(SB)
MOV $833, X7
JMP callbackasm1(SB)
MOV $834, X7
JMP callbackasm1(SB)
MOV $835, X7
JMP callbackasm1(SB)
MOV $836, X7
JMP callbackasm1(SB)
MOV $837, X7
JMP callbackasm1(SB)
MOV $838, X7
JMP callbackasm1(SB)
MOV $839, X7
JMP callbackasm1(SB)
MOV $840, X7
JMP callbackasm1(SB)
MOV $841, X7
JMP callbackasm1(SB)
MOV $842, X7
JMP callbackasm1(SB)
MOV $843, X7
JMP callbackasm1(SB)
MOV $844, X7
JMP callbackasm1(SB)
MOV $845, X7
JMP callbackasm1(SB)
MOV $846, X7
JMP callbackasm1(SB)
MOV $847, X7
JMP callbackasm1(SB)
MOV $848, X7
JMP callbackasm1(SB)
MOV $849, X7
JMP callbackasm1(SB)
MOV $850, X7
JMP callbackasm1(SB)
MOV $851, X7
JMP callbackasm1(SB)
MOV $852, X7
JMP callbackasm1(SB)
MOV $853, X7
JMP callbackasm1(SB)
MOV $854, X7
JMP callbackasm1(SB)
MOV $855, X7
JMP callbackasm1(SB)
MOV $856, X7
JMP callbackasm1(SB)
MOV $857, X7
JMP callbackasm1(SB)
MOV $858, X7
JMP callbackasm1(SB)
MOV $859, X7
JMP callbackasm1(SB)
MOV $860, X7
JMP callbackasm1(SB)
MOV $861, X7
JMP callbackasm1(SB)
MOV $862, X7
JMP callbackasm1(SB)
MOV $863, X7
JMP callbackasm1(SB)
MOV $864, X7
JMP callbackasm1(SB)
MOV $865, X7
JMP callbackasm1(SB)
MOV $866, X7
JMP callbackasm1(SB)
MOV $867, X7
JMP callbackasm1(SB)
MOV $868, X7
JMP callbackasm1(SB)
MOV $869, X7
JMP callbackasm1(SB)
MOV $870, X7
JMP callbackasm1(SB)
MOV $871, X7
JMP callbackasm1(SB)
MOV $872, X7
JMP callbackasm1(SB)
MOV $873, X7
JMP callbackasm1(SB)
MOV $874, X7
JMP callbackasm1(SB)
MOV $875, X7
JMP callbackasm1(SB)
MOV $876, X7
JMP callbackasm1(SB)
MOV $877, X7
JMP callbackasm1(SB)
MOV $878, X7
JMP callbackasm1(SB)
MOV $879, X7
JMP callbackasm1(SB)
MOV $880, X7
JMP callbackasm1(SB)
MOV $881, X7
JMP callbackasm1(SB)
MOV $882, X7
JMP callbackasm1(SB)
MOV $883, X7
JMP callbackasm1(SB)
MOV $884, X7
JMP callbackasm1(SB)
MOV $885, X7
JMP callbackasm1(SB)
MOV $886, X7
JMP callbackasm1(SB)
MOV $887, X7
JMP callbackasm1(SB)
MOV $888, X7
JMP callbackasm1(SB)
MOV $889, X7
JMP callbackasm1(SB)
MOV $890, X7
JMP callbackasm1(SB)
MOV $891, X7
JMP callbackasm1(SB)
MOV $892, X7
JMP callbackasm1(SB)
MOV $893, X7
JMP callbackasm1(SB)
MOV $894, X7
JMP callbackasm1(SB)
MOV $895, X7
JMP callbackasm1(SB)
MOV $896, X7
JMP callbackasm1(SB)
MOV $897, X7
JMP callbackasm1(SB)
MOV $898, X7
JMP callbackasm1(SB)
MOV $899, X7
JMP callbackasm1(SB)
MOV $900, X7
JMP callbackasm1(SB)
MOV $901, X7
JMP callbackasm1(SB)
MOV $902, X7
JMP callbackasm1(SB)
MOV $903, X7
JMP callbackasm1(SB)
MOV $904, X7
JMP callbackasm1(SB)
MOV $905, X7
JMP callbackasm1(SB)
MOV $906, X7
JMP callbackasm1(SB)
MOV $907, X7
JMP callbackasm1(SB)
MOV $908, X7
JMP callbackasm1(SB)
MOV $909, X7
JMP callbackasm1(SB)
MOV $910, X7
JMP callbackasm1(SB)
MOV $911, X7
JMP callbackasm1(SB)
MOV $912, X7
JMP callbackasm1(SB)
MOV $913, X7
JMP callbackasm1(SB)
MOV $914, X7
JMP callbackasm1(SB)
MOV $915, X7
JMP callbackasm1(SB)
MOV $916, X7
JMP callbackasm1(SB)
MOV $917, X7
JMP callbackasm1(SB)
MOV $918, X7
JMP callbackasm1(SB)
MOV $919, X7
JMP callbackasm1(SB)
MOV $920, X7
JMP callbackasm1(SB)
MOV $921, X7
JMP callbackasm1(SB)
MOV $922, X7
JMP callbackasm1(SB)
MOV $923, X7
JMP callbackasm1(SB)
MOV $924, X7
JMP callbackasm1(SB)
MOV $925, X7
JMP callbackasm1(SB)
MOV $926, X7
JMP callbackasm1(SB)
MOV $927, X7
JMP callbackasm1(SB)
MOV $928, X7
JMP callbackasm1(SB)
MOV $929, X7
JMP callbackasm1(SB)
MOV $930, X7
JMP callbackasm1(SB)
MOV $931, X7
JMP callbackasm1(SB)
MOV $932, X7
JMP callbackasm1(SB)
MOV $933, X7
JMP callbackasm1(SB)
MOV $934, X7
JMP callbackasm1(SB)
MOV $935, X7
JMP callbackasm1(SB)
MOV $936, X7
JMP callbackasm1(SB)
MOV $937, X7
JMP callbackasm1(SB)
MOV $938, X7
JMP callbackasm1(SB)
MOV $939, X7
JMP callbackasm1(SB)
MOV $940, X7
JMP callbackasm1(SB)
MOV $941, X7
JMP callbackasm1(SB)
MOV $942, X7
JMP callbackasm1(SB)
MOV $943, X7
JMP callbackasm1(SB)
MOV $944, X7
JMP callbackasm1(SB)
MOV $945, X7
JMP callbackasm1(SB)
MOV $946, X7
JMP callbackasm1(SB)
MOV $947, X7
JMP callbackasm1(SB)
MOV $948, X7
JMP callbackasm1(SB)
MOV $949, X7
JMP callbackasm1(SB)
MOV $950, X7
JMP callbackasm1(SB)
MOV $951, X7
JMP callbackasm1(SB)
MOV $952, X7
JMP callbackasm1(SB)
MOV $953, X7
JMP callbackasm1(SB)
MOV $954, X7
JMP callbackasm1(SB)
MOV $955, X7
JMP callbackasm1(SB)
MOV $956, X7
JMP callbackasm1(SB)
MOV $957, X7
JMP callbackasm1(SB)
MOV $958, X7
JMP callbackasm1(SB)
MOV $959, X7
JMP callbackasm1(SB)
MOV $960, X7
JMP callbackasm1(SB)
MOV $961, X7
JMP callbackasm1(SB)
MOV $962, X7
JMP callbackasm1(SB)
MOV $963, X7
JMP callbackasm1(SB)
MOV $964, X7
JMP callbackasm1(SB)
MOV $965, X7
JMP callbackasm1(SB)
MOV $966, X7
JMP callbackasm1(SB)
MOV $967, X7
JMP callbackasm1(SB)
MOV $968, X7
JMP callbackasm1(SB)
MOV $969, X7
JMP callbackasm1(SB)
MOV $970, X7
JMP callbackasm1(SB)
MOV $971, X7
JMP callbackasm1(SB)
MOV $972, X7
JMP callbackasm1(SB)
MOV $973, X7
JMP callbackasm1(SB)
MOV $974, X7
JMP callbackasm1(SB)
MOV $975, X7
JMP callbackasm1(SB)
MOV $976, X7
JMP callbackasm1(SB)
MOV $977, X7
JMP callbackasm1(SB)
MOV $978, X7
JMP callbackasm1(SB)
MOV $979, X7
JMP callbackasm1(SB)
MOV $980, X7
JMP callbackasm1(SB)
MOV $981, X7
JMP callbackasm1(SB)
MOV $982, X7
JMP callbackasm1(SB)
MOV $983, X7
JMP callbackasm1(SB)
MOV $984, X7
JMP callbackasm1(SB)
MOV $985, X7
JMP callbackasm1(SB)
MOV $986, X7
JMP callbackasm1(SB)
MOV $987, X7
JMP callbackasm1(SB)
MOV $988, X7
JMP callbackasm1(SB)
MOV $989, X7
JMP callbackasm1(SB)
MOV $990, X7
JMP callbackasm1(SB)
MOV $991, X7
JMP callbackasm1(SB)
MOV $992, X7
JMP callbackasm1(SB)
MOV $993, X7
JMP callbackasm1(SB)
MOV $994, X7
JMP callbackasm1(SB)
MOV $995, X7
JMP callbackasm1(SB)
MOV $996, X7
JMP callbackasm1(SB)
MOV $997, X7
JMP callbackasm1(SB)
MOV $998, X7
JMP callbackasm1(SB)
MOV $999, X7
JMP callbackasm1(SB)
MOV $1000, X7
JMP callbackasm1(SB)
MOV $1001, X7
JMP callbackasm1(SB)
MOV $1002, X7
JMP callbackasm1(SB)
MOV $1003, X7
JMP callbackasm1(SB)
MOV $1004, X7
JMP callbackasm1(SB)
MOV $1005, X7
JMP callbackasm1(SB)
MOV $1006, X7
JMP callbackasm1(SB)
MOV $1007, X7
JMP callbackasm1(SB)
MOV $1008, X7
JMP callbackasm1(SB)
MOV $1009, X7
JMP callbackasm1(SB)
MOV $1010, X7
JMP callbackasm1(SB)
MOV $1011, X7
JMP callbackasm1(SB)
MOV $1012, X7
JMP callbackasm1(SB)
MOV $1013, X7
JMP callbackasm1(SB)
MOV $1014, X7
JMP callbackasm1(SB)
MOV $1015, X7
JMP callbackasm1(SB)
MOV $1016, X7
JMP callbackasm1(SB)
MOV $1017, X7
JMP callbackasm1(SB)
MOV $1018, X7
JMP callbackasm1(SB)
MOV $1019, X7
JMP callbackasm1(SB)
MOV $1020, X7
JMP callbackasm1(SB)
MOV $1021, X7
JMP callbackasm1(SB)
MOV $1022, X7
JMP callbackasm1(SB)
MOV $1023, X7
JMP callbackasm1(SB)
MOV $1024, X7
JMP callbackasm1(SB)
MOV $1025, X7
JMP callbackasm1(SB)
MOV $1026, X7
JMP callbackasm1(SB)
MOV $1027, X7
JMP callbackasm1(SB)
MOV $1028, X7
JMP callbackasm1(SB)
MOV $1029, X7
JMP callbackasm1(SB)
MOV $1030, X7
JMP callbackasm1(SB)
MOV $1031, X7
JMP callbackasm1(SB)
MOV $1032, X7
JMP callbackasm1(SB)
MOV $1033, X7
JMP callbackasm1(SB)
MOV $1034, X7
JMP callbackasm1(SB)
MOV $1035, X7
JMP callbackasm1(SB)
MOV $1036, X7
JMP callbackasm1(SB)
MOV $1037, X7
JMP callbackasm1(SB)
MOV $1038, X7
JMP callbackasm1(SB)
MOV $1039, X7
JMP callbackasm1(SB)
MOV $1040, X7
JMP callbackasm1(SB)
MOV $1041, X7
JMP callbackasm1(SB)
MOV $1042, X7
JMP callbackasm1(SB)
MOV $1043, X7
JMP callbackasm1(SB)
MOV $1044, X7
JMP callbackasm1(SB)
MOV $1045, X7
JMP callbackasm1(SB)
MOV $1046, X7
JMP callbackasm1(SB)
MOV $1047, X7
JMP callbackasm1(SB)
MOV $1048, X7
JMP callbackasm1(SB)
MOV $1049, X7
JMP callbackasm1(SB)
MOV $1050, X7
JMP callbackasm1(SB)
MOV $1051, X7
JMP callbackasm1(SB)
MOV $1052, X7
JMP callbackasm1(SB)
MOV $1053, X7
JMP callbackasm1(SB)
MOV $1054, X7
JMP callbackasm1(SB)
MOV $1055, X7
JMP callbackasm1(SB)
MOV $1056, X7
JMP callbackasm1(SB)
MOV $1057, X7
JMP callbackasm1(SB)
MOV $1058, X7
JMP callbackasm1(SB)
MOV $1059, X7
JMP callbackasm1(SB)
MOV $1060, X7
JMP callbackasm1(SB)
MOV $1061, X7
JMP callbackasm1(SB)
MOV $1062, X7
JMP callbackasm1(SB)
MOV $1063, X7
JMP callbackasm1(SB)
MOV $1064, X7
JMP callbackasm1(SB)
MOV $1065, X7
JMP callbackasm1(SB)
MOV $1066, X7
JMP callbackasm1(SB)
MOV $1067, X7
JMP callbackasm1(SB)
MOV $1068, X7
JMP callbackasm1(SB)
MOV $1069, X7
JMP callbackasm1(SB)
MOV $1070, X7
JMP callbackasm1(SB)
MOV $1071, X7
JMP callbackasm1(SB)
MOV $1072, X7
JMP callbackasm1(SB)
MOV $1073, X7
JMP callbackasm1(SB)
MOV $1074, X7
JMP callbackasm1(SB)
MOV $1075, X7
JMP callbackasm1(SB)
MOV $1076, X7
JMP callbackasm1(SB)
MOV $1077, X7
JMP callbackasm1(SB)
MOV $1078, X7
JMP callbackasm1(SB)
MOV $1079, X7
JMP callbackasm1(SB)
MOV $1080, X7
JMP callbackasm1(SB)
MOV $1081, X7
JMP callbackasm1(SB)
MOV $1082, X7
JMP callbackasm1(SB)
MOV $1083, X7
JMP callbackasm1(SB)
MOV $1084, X7
JMP callbackasm1(SB)
MOV $1085, X7
JMP callbackasm1(SB)
MOV $1086, X7
JMP callbackasm1(SB)
MOV $1087, X7
JMP callbackasm1(SB)
MOV $1088, X7
JMP callbackasm1(SB)
MOV $1089, X7
JMP callbackasm1(SB)
MOV $1090, X7
JMP callbackasm1(SB)
MOV $1091, X7
JMP callbackasm1(SB)
MOV $1092, X7
JMP callbackasm1(SB)
MOV $1093, X7
JMP callbackasm1(SB)
MOV $1094, X7
JMP callbackasm1(SB)
MOV $1095, X7
JMP callbackasm1(SB)
MOV $1096, X7
JMP callbackasm1(SB)
MOV $1097, X7
JMP callbackasm1(SB)
MOV $1098, X7
JMP callbackasm1(SB)
MOV $1099, X7
JMP callbackasm1(SB)
MOV $1100, X7
JMP callbackasm1(SB)
MOV $1101, X7
JMP callbackasm1(SB)
MOV $1102, X7
JMP callbackasm1(SB)
MOV $1103, X7
JMP callbackasm1(SB)
MOV $1104, X7
JMP callbackasm1(SB)
MOV $1105, X7
JMP callbackasm1(SB)
MOV $1106, X7
JMP callbackasm1(SB)
MOV $1107, X7
JMP callbackasm1(SB)
MOV $1108, X7
JMP callbackasm1(SB)
MOV $1109, X7
JMP callbackasm1(SB)
MOV $1110, X7
JMP callbackasm1(SB)
MOV $1111, X7
JMP callbackasm1(SB)
MOV $1112, X7
JMP callbackasm1(SB)
MOV $1113, X7
JMP callbackasm1(SB)
MOV $1114, X7
JMP callbackasm1(SB)
MOV $1115, X7
JMP callbackasm1(SB)
MOV $1116, X7
JMP callbackasm1(SB)
MOV $1117, X7
JMP callbackasm1(SB)
MOV $1118, X7
JMP callbackasm1(SB)
MOV $1119, X7
JMP callbackasm1(SB)
MOV $1120, X7
JMP callbackasm1(SB)
MOV $1121, X7
JMP callbackasm1(SB)
MOV $1122, X7
JMP callbackasm1(SB)
MOV $1123, X7
JMP callbackasm1(SB)
MOV $1124, X7
JMP callbackasm1(SB)
MOV $1125, X7
JMP callbackasm1(SB)
MOV $1126, X7
JMP callbackasm1(SB)
MOV $1127, X7
JMP callbackasm1(SB)
MOV $1128, X7
JMP callbackasm1(SB)
MOV $1129, X7
JMP callbackasm1(SB)
MOV $1130, X7
JMP callbackasm1(SB)
MOV $1131, X7
JMP callbackasm1(SB)
MOV $1132, X7
JMP callbackasm1(SB)
MOV $1133, X7
JMP callbackasm1(SB)
MOV $1134, X7
JMP callbackasm1(SB)
MOV $1135, X7
JMP callbackasm1(SB)
MOV $1136, X7
JMP callbackasm1(SB)
MOV $1137, X7
JMP callbackasm1(SB)
MOV $1138, X7
JMP callbackasm1(SB)
MOV $1139, X7
JMP callbackasm1(SB)
MOV $1140, X7
JMP callbackasm1(SB)
MOV $1141, X7
JMP callbackasm1(SB)
MOV $1142, X7
JMP callbackasm1(SB)
MOV $1143, X7
JMP callbackasm1(SB)
MOV $1144, X7
JMP callbackasm1(SB)
MOV $1145, X7
JMP callbackasm1(SB)
MOV $1146, X7
JMP callbackasm1(SB)
MOV $1147, X7
JMP callbackasm1(SB)
MOV $1148, X7
JMP callbackasm1(SB)
MOV $1149, X7
JMP callbackasm1(SB)
MOV $1150, X7
JMP callbackasm1(SB)
MOV $1151, X7
JMP callbackasm1(SB)
MOV $1152, X7
JMP callbackasm1(SB)
MOV $1153, X7
JMP callbackasm1(SB)
MOV $1154, X7
JMP callbackasm1(SB)
MOV $1155, X7
JMP callbackasm1(SB)
MOV $1156, X7
JMP callbackasm1(SB)
MOV $1157, X7
JMP callbackasm1(SB)
MOV $1158, X7
JMP callbackasm1(SB)
MOV $1159, X7
JMP callbackasm1(SB)
MOV $1160, X7
JMP callbackasm1(SB)
MOV $1161, X7
JMP callbackasm1(SB)
MOV $1162, X7
JMP callbackasm1(SB)
MOV $1163, X7
JMP callbackasm1(SB)
MOV $1164, X7
JMP callbackasm1(SB)
MOV $1165, X7
JMP callbackasm1(SB)
MOV $1166, X7
JMP callbackasm1(SB)
MOV $1167, X7
JMP callbackasm1(SB)
MOV $1168, X7
JMP callbackasm1(SB)
MOV $1169, X7
JMP callbackasm1(SB)
MOV $1170, X7
JMP callbackasm1(SB)
MOV $1171, X7
JMP callbackasm1(SB)
MOV $1172, X7
JMP callbackasm1(SB)
MOV $1173, X7
JMP callbackasm1(SB)
MOV $1174, X7
JMP callbackasm1(SB)
MOV $1175, X7
JMP callbackasm1(SB)
MOV $1176, X7
JMP callbackasm1(SB)
MOV $1177, X7
JMP callbackasm1(SB)
MOV $1178, X7
JMP callbackasm1(SB)
MOV $1179, X7
JMP callbackasm1(SB)
MOV $1180, X7
JMP callbackasm1(SB)
MOV $1181, X7
JMP callbackasm1(SB)
MOV $1182, X7
JMP callbackasm1(SB)
MOV $1183, X7
JMP callbackasm1(SB)
MOV $1184, X7
JMP callbackasm1(SB)
MOV $1185, X7
JMP callbackasm1(SB)
MOV $1186, X7
JMP callbackasm1(SB)
MOV $1187, X7
JMP callbackasm1(SB)
MOV $1188, X7
JMP callbackasm1(SB)
MOV $1189, X7
JMP callbackasm1(SB)
MOV $1190, X7
JMP callbackasm1(SB)
MOV $1191, X7
JMP callbackasm1(SB)
MOV $1192, X7
JMP callbackasm1(SB)
MOV $1193, X7
JMP callbackasm1(SB)
MOV $1194, X7
JMP callbackasm1(SB)
MOV $1195, X7
JMP callbackasm1(SB)
MOV $1196, X7
JMP callbackasm1(SB)
MOV $1197, X7
JMP callbackasm1(SB)
MOV $1198, X7
JMP callbackasm1(SB)
MOV $1199, X7
JMP callbackasm1(SB)
MOV $1200, X7
JMP callbackasm1(SB)
MOV $1201, X7
JMP callbackasm1(SB)
MOV $1202, X7
JMP callbackasm1(SB)
MOV $1203, X7
JMP callbackasm1(SB)
MOV $1204, X7
JMP callbackasm1(SB)
MOV $1205, X7
JMP callbackasm1(SB)
MOV $1206, X7
JMP callbackasm1(SB)
MOV $1207, X7
JMP callbackasm1(SB)
MOV $1208, X7
JMP callbackasm1(SB)
MOV $1209, X7
JMP callbackasm1(SB)
MOV $1210, X7
JMP callbackasm1(SB)
MOV $1211, X7
JMP callbackasm1(SB)
MOV $1212, X7
JMP callbackasm1(SB)
MOV $1213, X7
JMP callbackasm1(SB)
MOV $1214, X7
JMP callbackasm1(SB)
MOV $1215, X7
JMP callbackasm1(SB)
MOV $1216, X7
JMP callbackasm1(SB)
MOV $1217, X7
JMP callbackasm1(SB)
MOV $1218, X7
JMP callbackasm1(SB)
MOV $1219, X7
JMP callbackasm1(SB)
MOV $1220, X7
JMP callbackasm1(SB)
MOV $1221, X7
JMP callbackasm1(SB)
MOV $1222, X7
JMP callbackasm1(SB)
MOV $1223, X7
JMP callbackasm1(SB)
MOV $1224, X7
JMP callbackasm1(SB)
MOV $1225, X7
JMP callbackasm1(SB)
MOV $1226, X7
JMP callbackasm1(SB)
MOV $1227, X7
JMP callbackasm1(SB)
MOV $1228, X7
JMP callbackasm1(SB)
MOV $1229, X7
JMP callbackasm1(SB)
MOV $1230, X7
JMP callbackasm1(SB)
MOV $1231, X7
JMP callbackasm1(SB)
MOV $1232, X7
JMP callbackasm1(SB)
MOV $1233, X7
JMP callbackasm1(SB)
MOV $1234, X7
JMP callbackasm1(SB)
MOV $1235, X7
JMP callbackasm1(SB)
MOV $1236, X7
JMP callbackasm1(SB)
MOV $1237, X7
JMP callbackasm1(SB)
MOV $1238, X7
JMP callbackasm1(SB)
MOV $1239, X7
JMP callbackasm1(SB)
MOV $1240, X7
JMP callbackasm1(SB)
MOV $1241, X7
JMP callbackasm1(SB)
MOV $1242, X7
JMP callbackasm1(SB)
MOV $1243, X7
JMP callbackasm1(SB)
MOV $1244, X7
JMP callbackasm1(SB)
MOV $1245, X7
JMP callbackasm1(SB)
MOV $1246, X7
JMP callbackasm1(SB)
MOV $1247, X7
JMP callbackasm1(SB)
MOV $1248, X7
JMP callbackasm1(SB)
MOV $1249, X7
JMP callbackasm1(SB)
MOV $1250, X7
JMP callbackasm1(SB)
MOV $1251, X7
JMP callbackasm1(SB)
MOV $1252, X7
JMP callbackasm1(SB)
MOV $1253, X7
JMP callbackasm1(SB)
MOV $1254, X7
JMP callbackasm1(SB)
MOV $1255, X7
JMP callbackasm1(SB)
MOV $1256, X7
JMP callbackasm1(SB)
MOV $1257, X7
JMP callbackasm1(SB)
MOV $1258, X7
JMP callbackasm1(SB)
MOV $1259, X7
JMP callbackasm1(SB)
MOV $1260, X7
JMP callbackasm1(SB)
MOV $1261, X7
JMP callbackasm1(SB)
MOV $1262, X7
JMP callbackasm1(SB)
MOV $1263, X7
JMP callbackasm1(SB)
MOV $1264, X7
JMP callbackasm1(SB)
MOV $1265, X7
JMP callbackasm1(SB)
MOV $1266, X7
JMP callbackasm1(SB)
MOV $1267, X7
JMP callbackasm1(SB)
MOV $1268, X7
JMP callbackasm1(SB)
MOV $1269, X7
JMP callbackasm1(SB)
MOV $1270, X7
JMP callbackasm1(SB)
MOV $1271, X7
JMP callbackasm1(SB)
MOV $1272, X7
JMP callbackasm1(SB)
MOV $1273, X7
JMP callbackasm1(SB)
MOV $1274, X7
JMP callbackasm1(SB)
MOV $1275, X7
JMP callbackasm1(SB)
MOV $1276, X7
JMP callbackasm1(SB)
MOV $1277, X7
JMP callbackasm1(SB)
MOV $1278, X7
JMP callbackasm1(SB)
MOV $1279, X7
JMP callbackasm1(SB)
MOV $1280, X7
JMP callbackasm1(SB)
MOV $1281, X7
JMP callbackasm1(SB)
MOV $1282, X7
JMP callbackasm1(SB)
MOV $1283, X7
JMP callbackasm1(SB)
MOV $1284, X7
JMP callbackasm1(SB)
MOV $1285, X7
JMP callbackasm1(SB)
MOV $1286, X7
JMP callbackasm1(SB)
MOV $1287, X7
JMP callbackasm1(SB)
MOV $1288, X7
JMP callbackasm1(SB)
MOV $1289, X7
JMP callbackasm1(SB)
MOV $1290, X7
JMP callbackasm1(SB)
MOV $1291, X7
JMP callbackasm1(SB)
MOV $1292, X7
JMP callbackasm1(SB)
MOV $1293, X7
JMP callbackasm1(SB)
MOV $1294, X7
JMP callbackasm1(SB)
MOV $1295, X7
JMP callbackasm1(SB)
MOV $1296, X7
JMP callbackasm1(SB)
MOV $1297, X7
JMP callbackasm1(SB)
MOV $1298, X7
JMP callbackasm1(SB)
MOV $1299, X7
JMP callbackasm1(SB)
MOV $1300, X7
JMP callbackasm1(SB)
MOV $1301, X7
JMP callbackasm1(SB)
MOV $1302, X7
JMP callbackasm1(SB)
MOV $1303, X7
JMP callbackasm1(SB)
MOV $1304, X7
JMP callbackasm1(SB)
MOV $1305, X7
JMP callbackasm1(SB)
MOV $1306, X7
JMP callbackasm1(SB)
MOV $1307, X7
JMP callbackasm1(SB)
MOV $1308, X7
JMP callbackasm1(SB)
MOV $1309, X7
JMP callbackasm1(SB)
MOV $1310, X7
JMP callbackasm1(SB)
MOV $1311, X7
JMP callbackasm1(SB)
MOV $1312, X7
JMP callbackasm1(SB)
MOV $1313, X7
JMP callbackasm1(SB)
MOV $1314, X7
JMP callbackasm1(SB)
MOV $1315, X7
JMP callbackasm1(SB)
MOV $1316, X7
JMP callbackasm1(SB)
MOV $1317, X7
JMP callbackasm1(SB)
MOV $1318, X7
JMP callbackasm1(SB)
MOV $1319, X7
JMP callbackasm1(SB)
MOV $1320, X7
JMP callbackasm1(SB)
MOV $1321, X7
JMP callbackasm1(SB)
MOV $1322, X7
JMP callbackasm1(SB)
MOV $1323, X7
JMP callbackasm1(SB)
MOV $1324, X7
JMP callbackasm1(SB)
MOV $1325, X7
JMP callbackasm1(SB)
MOV $1326, X7
JMP callbackasm1(SB)
MOV $1327, X7
JMP callbackasm1(SB)
MOV $1328, X7
JMP callbackasm1(SB)
MOV $1329, X7
JMP callbackasm1(SB)
MOV $1330, X7
JMP callbackasm1(SB)
MOV $1331, X7
JMP callbackasm1(SB)
MOV $1332, X7
JMP callbackasm1(SB)
MOV $1333, X7
JMP callbackasm1(SB)
MOV $1334, X7
JMP callbackasm1(SB)
MOV $1335, X7
JMP callbackasm1(SB)
MOV $1336, X7
JMP callbackasm1(SB)
MOV $1337, X7
JMP callbackasm1(SB)
MOV $1338, X7
JMP callbackasm1(SB)
MOV $1339, X7
JMP callbackasm1(SB)
MOV $1340, X7
JMP callbackasm1(SB)
MOV $1341, X7
JMP callbackasm1(SB)
MOV $1342, X7
JMP callbackasm1(SB)
MOV $1343, X7
JMP callbackasm1(SB)
MOV $1344, X7
JMP callbackasm1(SB)
MOV $1345, X7
JMP callbackasm1(SB)
MOV $1346, X7
JMP callbackasm1(SB)
MOV $1347, X7
JMP callbackasm1(SB)
MOV $1348, X7
JMP callbackasm1(SB)
MOV $1349, X7
JMP callbackasm1(SB)
MOV $1350, X7
JMP callbackasm1(SB)
MOV $1351, X7
JMP callbackasm1(SB)
MOV $1352, X7
JMP callbackasm1(SB)
MOV $1353, X7
JMP callbackasm1(SB)
MOV $1354, X7
JMP callbackasm1(SB)
MOV $1355, X7
JMP callbackasm1(SB)
MOV $1356, X7
JMP callbackasm1(SB)
MOV $1357, X7
JMP callbackasm1(SB)
MOV $1358, X7
JMP callbackasm1(SB)
MOV $1359, X7
JMP callbackasm1(SB)
MOV $1360, X7
JMP callbackasm1(SB)
MOV $1361, X7
JMP callbackasm1(SB)
MOV $1362, X7
JMP callbackasm1(SB)
MOV $1363, X7
JMP callbackasm1(SB)
MOV $1364, X7
JMP callbackasm1(SB)
MOV $1365, X7
JMP callbackasm1(SB)
MOV $1366, X7
JMP callbackasm1(SB)
MOV $1367, X7
JMP callbackasm1(SB)
MOV $1368, X7
JMP callbackasm1(SB)
MOV $1369, X7
JMP callbackasm1(SB)
MOV $1370, X7
JMP callbackasm1(SB)
MOV $1371, X7
JMP callbackasm1(SB)
MOV $1372, X7
JMP callbackasm1(SB)
MOV $1373, X7
JMP callbackasm1(SB)
MOV $1374, X7
JMP callbackasm1(SB)
MOV $1375, X7
JMP callbackasm1(SB)
MOV $1376, X7
JMP callbackasm1(SB)
MOV $1377, X7
JMP callbackasm1(SB)
MOV $1378, X7
JMP callbackasm1(SB)
MOV $1379, X7
JMP callbackasm1(SB)
MOV $1380, X7
JMP callbackasm1(SB)
MOV $1381, X7
JMP callbackasm1(SB)
MOV $1382, X7
JMP callbackasm1(SB)
MOV $1383, X7
JMP callbackasm1(SB)
MOV $1384, X7
JMP callbackasm1(SB)
MOV $1385, X7
JMP callbackasm1(SB)
MOV $1386, X7
JMP callbackasm1(SB)
MOV $1387, X7
JMP callbackasm1(SB)
MOV $1388, X7
JMP callbackasm1(SB)
MOV $1389, X7
JMP callbackasm1(SB)
MOV $1390, X7
JMP callbackasm1(SB)
MOV $1391, X7
JMP callbackasm1(SB)
MOV $1392, X7
JMP callbackasm1(SB)
MOV $1393, X7
JMP callbackasm1(SB)
MOV $1394, X7
JMP callbackasm1(SB)
MOV $1395, X7
JMP callbackasm1(SB)
MOV $1396, X7
JMP callbackasm1(SB)
MOV $1397, X7
JMP callbackasm1(SB)
MOV $1398, X7
JMP callbackasm1(SB)
MOV $1399, X7
JMP callbackasm1(SB)
MOV $1400, X7
JMP callbackasm1(SB)
MOV $1401, X7
JMP callbackasm1(SB)
MOV $1402, X7
JMP callbackasm1(SB)
MOV $1403, X7
JMP callbackasm1(SB)
MOV $1404, X7
JMP callbackasm1(SB)
MOV $1405, X7
JMP callbackasm1(SB)
MOV $1406, X7
JMP callbackasm1(SB)
MOV $1407, X7
JMP callbackasm1(SB)
MOV $1408, X7
JMP callbackasm1(SB)
MOV $1409, X7
JMP callbackasm1(SB)
MOV $1410, X7
JMP callbackasm1(SB)
MOV $1411, X7
JMP callbackasm1(SB)
MOV $1412, X7
JMP callbackasm1(SB)
MOV $1413, X7
JMP callbackasm1(SB)
MOV $1414, X7
JMP callbackasm1(SB)
MOV $1415, X7
JMP callbackasm1(SB)
MOV $1416, X7
JMP callbackasm1(SB)
MOV $1417, X7
JMP callbackasm1(SB)
MOV $1418, X7
JMP callbackasm1(SB)
MOV $1419, X7
JMP callbackasm1(SB)
MOV $1420, X7
JMP callbackasm1(SB)
MOV $1421, X7
JMP callbackasm1(SB)
MOV $1422, X7
JMP callbackasm1(SB)
MOV $1423, X7
JMP callbackasm1(SB)
MOV $1424, X7
JMP callbackasm1(SB)
MOV $1425, X7
JMP callbackasm1(SB)
MOV $1426, X7
JMP callbackasm1(SB)
MOV $1427, X7
JMP callbackasm1(SB)
MOV $1428, X7
JMP callbackasm1(SB)
MOV $1429, X7
JMP callbackasm1(SB)
MOV $1430, X7
JMP callbackasm1(SB)
MOV $1431, X7
JMP callbackasm1(SB)
MOV $1432, X7
JMP callbackasm1(SB)
MOV $1433, X7
JMP callbackasm1(SB)
MOV $1434, X7
JMP callbackasm1(SB)
MOV $1435, X7
JMP callbackasm1(SB)
MOV $1436, X7
JMP callbackasm1(SB)
MOV $1437, X7
JMP callbackasm1(SB)
MOV $1438, X7
JMP callbackasm1(SB)
MOV $1439, X7
JMP callbackasm1(SB)
MOV $1440, X7
JMP callbackasm1(SB)
MOV $1441, X7
JMP callbackasm1(SB)
MOV $1442, X7
JMP callbackasm1(SB)
MOV $1443, X7
JMP callbackasm1(SB)
MOV $1444, X7
JMP callbackasm1(SB)
MOV $1445, X7
JMP callbackasm1(SB)
MOV $1446, X7
JMP callbackasm1(SB)
MOV $1447, X7
JMP callbackasm1(SB)
MOV $1448, X7
JMP callbackasm1(SB)
MOV $1449, X7
JMP callbackasm1(SB)
MOV $1450, X7
JMP callbackasm1(SB)
MOV $1451, X7
JMP callbackasm1(SB)
MOV $1452, X7
JMP callbackasm1(SB)
MOV $1453, X7
JMP callbackasm1(SB)
MOV $1454, X7
JMP callbackasm1(SB)
MOV $1455, X7
JMP callbackasm1(SB)
MOV $1456, X7
JMP callbackasm1(SB)
MOV $1457, X7
JMP callbackasm1(SB)
MOV $1458, X7
JMP callbackasm1(SB)
MOV $1459, X7
JMP callbackasm1(SB)
MOV $1460, X7
JMP callbackasm1(SB)
MOV $1461, X7
JMP callbackasm1(SB)
MOV $1462, X7
JMP callbackasm1(SB)
MOV $1463, X7
JMP callbackasm1(SB)
MOV $1464, X7
JMP callbackasm1(SB)
MOV $1465, X7
JMP callbackasm1(SB)
MOV $1466, X7
JMP callbackasm1(SB)
MOV $1467, X7
JMP callbackasm1(SB)
MOV $1468, X7
JMP callbackasm1(SB)
MOV $1469, X7
JMP callbackasm1(SB)
MOV $1470, X7
JMP callbackasm1(SB)
MOV $1471, X7
JMP callbackasm1(SB)
MOV $1472, X7
JMP callbackasm1(SB)
MOV $1473, X7
JMP callbackasm1(SB)
MOV $1474, X7
JMP callbackasm1(SB)
MOV $1475, X7
JMP callbackasm1(SB)
MOV $1476, X7
JMP callbackasm1(SB)
MOV $1477, X7
JMP callbackasm1(SB)
MOV $1478, X7
JMP callbackasm1(SB)
MOV $1479, X7
JMP callbackasm1(SB)
MOV $1480, X7
JMP callbackasm1(SB)
MOV $1481, X7
JMP callbackasm1(SB)
MOV $1482, X7
JMP callbackasm1(SB)
MOV $1483, X7
JMP callbackasm1(SB)
MOV $1484, X7
JMP callbackasm1(SB)
MOV $1485, X7
JMP callbackasm1(SB)
MOV $1486, X7
JMP callbackasm1(SB)
MOV $1487, X7
JMP callbackasm1(SB)
MOV $1488, X7
JMP callbackasm1(SB)
MOV $1489, X7
JMP callbackasm1(SB)
MOV $1490, X7
JMP callbackasm1(SB)
MOV $1491, X7
JMP callbackasm1(SB)
MOV $1492, X7
JMP callbackasm1(SB)
MOV $1493, X7
JMP callbackasm1(SB)
MOV $1494, X7
JMP callbackasm1(SB)
MOV $1495, X7
JMP callbackasm1(SB)
MOV $1496, X7
JMP callbackasm1(SB)
MOV $1497, X7
JMP callbackasm1(SB)
MOV $1498, X7
JMP callbackasm1(SB)
MOV $1499, X7
JMP callbackasm1(SB)
MOV $1500, X7
JMP callbackasm1(SB)
MOV $1501, X7
JMP callbackasm1(SB)
MOV $1502, X7
JMP callbackasm1(SB)
MOV $1503, X7
JMP callbackasm1(SB)
MOV $1504, X7
JMP callbackasm1(SB)
MOV $1505, X7
JMP callbackasm1(SB)
MOV $1506, X7
JMP callbackasm1(SB)
MOV $1507, X7
JMP callbackasm1(SB)
MOV $1508, X7
JMP callbackasm1(SB)
MOV $1509, X7
JMP callbackasm1(SB)
MOV $1510, X7
JMP callbackasm1(SB)
MOV $1511, X7
JMP callbackasm1(SB)
MOV $1512, X7
JMP callbackasm1(SB)
MOV $1513, X7
JMP callbackasm1(SB)
MOV $1514, X7
JMP callbackasm1(SB)
MOV $1515, X7
JMP callbackasm1(SB)
MOV $1516, X7
JMP callbackasm1(SB)
MOV $1517, X7
JMP callbackasm1(SB)
MOV $1518, X7
JMP callbackasm1(SB)
MOV $1519, X7
JMP callbackasm1(SB)
MOV $1520, X7
JMP callbackasm1(SB)
MOV $1521, X7
JMP callbackasm1(SB)
MOV $1522, X7
JMP callbackasm1(SB)
MOV $1523, X7
JMP callbackasm1(SB)
MOV $1524, X7
JMP callbackasm1(SB)
MOV $1525, X7
JMP callbackasm1(SB)
MOV $1526, X7
JMP callbackasm1(SB)
MOV $1527, X7
JMP callbackasm1(SB)
MOV $1528, X7
JMP callbackasm1(SB)
MOV $1529, X7
JMP callbackasm1(SB)
MOV $1530, X7
JMP callbackasm1(SB)
MOV $1531, X7
JMP callbackasm1(SB)
MOV $1532, X7
JMP callbackasm1(SB)
MOV $1533, X7
JMP callbackasm1(SB)
MOV $1534, X7
JMP callbackasm1(SB)
MOV $1535, X7
JMP callbackasm1(SB)
MOV $1536, X7
JMP callbackasm1(SB)
MOV $1537, X7
JMP callbackasm1(SB)
MOV $1538, X7
JMP callbackasm1(SB)
MOV $1539, X7
JMP callbackasm1(SB)
MOV $1540, X7
JMP callbackasm1(SB)
MOV $1541, X7
JMP callbackasm1(SB)
MOV $1542, X7
JMP callbackasm1(SB)
MOV $1543, X7
JMP callbackasm1(SB)
MOV $1544, X7
JMP callbackasm1(SB)
MOV $1545, X7
JMP callbackasm1(SB)
MOV $1546, X7
JMP callbackasm1(SB)
MOV $1547, X7
JMP callbackasm1(SB)
MOV $1548, X7
JMP callbackasm1(SB)
MOV $1549, X7
JMP callbackasm1(SB)
MOV $1550, X7
JMP callbackasm1(SB)
MOV $1551, X7
JMP callbackasm1(SB)
MOV $1552, X7
JMP callbackasm1(SB)
MOV $1553, X7
JMP callbackasm1(SB)
MOV $1554, X7
JMP callbackasm1(SB)
MOV $1555, X7
JMP callbackasm1(SB)
MOV $1556, X7
JMP callbackasm1(SB)
MOV $1557, X7
JMP callbackasm1(SB)
MOV $1558, X7
JMP callbackasm1(SB)
MOV $1559, X7
JMP callbackasm1(SB)
MOV $1560, X7
JMP callbackasm1(SB)
MOV $1561, X7
JMP callbackasm1(SB)
MOV $1562, X7
JMP callbackasm1(SB)
MOV $1563, X7
JMP callbackasm1(SB)
MOV $1564, X7
JMP callbackasm1(SB)
MOV $1565, X7
JMP callbackasm1(SB)
MOV $1566, X7
JMP callbackasm1(SB)
MOV $1567, X7
JMP callbackasm1(SB)
MOV $1568, X7
JMP callbackasm1(SB)
MOV $1569, X7
JMP callbackasm1(SB)
MOV $1570, X7
JMP callbackasm1(SB)
MOV $1571, X7
JMP callbackasm1(SB)
MOV $1572, X7
JMP callbackasm1(SB)
MOV $1573, X7
JMP callbackasm1(SB)
MOV $1574, X7
JMP callbackasm1(SB)
MOV $1575, X7
JMP callbackasm1(SB)
MOV $1576, X7
JMP callbackasm1(SB)
MOV $1577, X7
JMP callbackasm1(SB)
MOV $1578, X7
JMP callbackasm1(SB)
MOV $1579, X7
JMP callbackasm1(SB)
MOV $1580, X7
JMP callbackasm1(SB)
MOV $1581, X7
JMP callbackasm1(SB)
MOV $1582, X7
JMP callbackasm1(SB)
MOV $1583, X7
JMP callbackasm1(SB)
MOV $1584, X7
JMP callbackasm1(SB)
MOV $1585, X7
JMP callbackasm1(SB)
MOV $1586, X7
JMP callbackasm1(SB)
MOV $1587, X7
JMP callbackasm1(SB)
MOV $1588, X7
JMP callbackasm1(SB)
MOV $1589, X7
JMP callbackasm1(SB)
MOV $1590, X7
JMP callbackasm1(SB)
MOV $1591, X7
JMP callbackasm1(SB)
MOV $1592, X7
JMP callbackasm1(SB)
MOV $1593, X7
JMP callbackasm1(SB)
MOV $1594, X7
JMP callbackasm1(SB)
MOV $1595, X7
JMP callbackasm1(SB)
MOV $1596, X7
JMP callbackasm1(SB)
MOV $1597, X7
JMP callbackasm1(SB)
MOV $1598, X7
JMP callbackasm1(SB)
MOV $1599, X7
JMP callbackasm1(SB)
MOV $1600, X7
JMP callbackasm1(SB)
MOV $1601, X7
JMP callbackasm1(SB)
MOV $1602, X7
JMP callbackasm1(SB)
MOV $1603, X7
JMP callbackasm1(SB)
MOV $1604, X7
JMP callbackasm1(SB)
MOV $1605, X7
JMP callbackasm1(SB)
MOV $1606, X7
JMP callbackasm1(SB)
MOV $1607, X7
JMP callbackasm1(SB)
MOV $1608, X7
JMP callbackasm1(SB)
MOV $1609, X7
JMP callbackasm1(SB)
MOV $1610, X7
JMP callbackasm1(SB)
MOV $1611, X7
JMP callbackasm1(SB)
MOV $1612, X7
JMP callbackasm1(SB)
MOV $1613, X7
JMP callbackasm1(SB)
MOV $1614, X7
JMP callbackasm1(SB)
MOV $1615, X7
JMP callbackasm1(SB)
MOV $1616, X7
JMP callbackasm1(SB)
MOV $1617, X7
JMP callbackasm1(SB)
MOV $1618, X7
JMP callbackasm1(SB)
MOV $1619, X7
JMP callbackasm1(SB)
MOV $1620, X7
JMP callbackasm1(SB)
MOV $1621, X7
JMP callbackasm1(SB)
MOV $1622, X7
JMP callbackasm1(SB)
MOV $1623, X7
JMP callbackasm1(SB)
MOV $1624, X7
JMP callbackasm1(SB)
MOV $1625, X7
JMP callbackasm1(SB)
MOV $1626, X7
JMP callbackasm1(SB)
MOV $1627, X7
JMP callbackasm1(SB)
MOV $1628, X7
JMP callbackasm1(SB)
MOV $1629, X7
JMP callbackasm1(SB)
MOV $1630, X7
JMP callbackasm1(SB)
MOV $1631, X7
JMP callbackasm1(SB)
MOV $1632, X7
JMP callbackasm1(SB)
MOV $1633, X7
JMP callbackasm1(SB)
MOV $1634, X7
JMP callbackasm1(SB)
MOV $1635, X7
JMP callbackasm1(SB)
MOV $1636, X7
JMP callbackasm1(SB)
MOV $1637, X7
JMP callbackasm1(SB)
MOV $1638, X7
JMP callbackasm1(SB)
MOV $1639, X7
JMP callbackasm1(SB)
MOV $1640, X7
JMP callbackasm1(SB)
MOV $1641, X7
JMP callbackasm1(SB)
MOV $1642, X7
JMP callbackasm1(SB)
MOV $1643, X7
JMP callbackasm1(SB)
MOV $1644, X7
JMP callbackasm1(SB)
MOV $1645, X7
JMP callbackasm1(SB)
MOV $1646, X7
JMP callbackasm1(SB)
MOV $1647, X7
JMP callbackasm1(SB)
MOV $1648, X7
JMP callbackasm1(SB)
MOV $1649, X7
JMP callbackasm1(SB)
MOV $1650, X7
JMP callbackasm1(SB)
MOV $1651, X7
JMP callbackasm1(SB)
MOV $1652, X7
JMP callbackasm1(SB)
MOV $1653, X7
JMP callbackasm1(SB)
MOV $1654, X7
JMP callbackasm1(SB)
MOV $1655, X7
JMP callbackasm1(SB)
MOV $1656, X7
JMP callbackasm1(SB)
MOV $1657, X7
JMP callbackasm1(SB)
MOV $1658, X7
JMP callbackasm1(SB)
MOV $1659, X7
JMP callbackasm1(SB)
MOV $1660, X7
JMP callbackasm1(SB)
MOV $1661, X7
JMP callbackasm1(SB)
MOV $1662, X7
JMP callbackasm1(SB)
MOV $1663, X7
JMP callbackasm1(SB)
MOV $1664, X7
JMP callbackasm1(SB)
MOV $1665, X7
JMP callbackasm1(SB)
MOV $1666, X7
JMP callbackasm1(SB)
MOV $1667, X7
JMP callbackasm1(SB)
MOV $1668, X7
JMP callbackasm1(SB)
MOV $1669, X7
JMP callbackasm1(SB)
MOV $1670, X7
JMP callbackasm1(SB)
MOV $1671, X7
JMP callbackasm1(SB)
MOV $1672, X7
JMP callbackasm1(SB)
MOV $1673, X7
JMP callbackasm1(SB)
MOV $1674, X7
JMP callbackasm1(SB)
MOV $1675, X7
JMP callbackasm1(SB)
MOV $1676, X7
JMP callbackasm1(SB)
MOV $1677, X7
JMP callbackasm1(SB)
MOV $1678, X7
JMP callbackasm1(SB)
MOV $1679, X7
JMP callbackasm1(SB)
MOV $1680, X7
JMP callbackasm1(SB)
MOV $1681, X7
JMP callbackasm1(SB)
MOV $1682, X7
JMP callbackasm1(SB)
MOV $1683, X7
JMP callbackasm1(SB)
MOV $1684, X7
JMP callbackasm1(SB)
MOV $1685, X7
JMP callbackasm1(SB)
MOV $1686, X7
JMP callbackasm1(SB)
MOV $1687, X7
JMP callbackasm1(SB)
MOV $1688, X7
JMP callbackasm1(SB)
MOV $1689, X7
JMP callbackasm1(SB)
MOV $1690, X7
JMP callbackasm1(SB)
MOV $1691, X7
JMP callbackasm1(SB)
MOV $1692, X7
JMP callbackasm1(SB)
MOV $1693, X7
JMP callbackasm1(SB)
MOV $1694, X7
JMP callbackasm1(SB)
MOV $1695, X7
JMP callbackasm1(SB)
MOV $1696, X7
JMP callbackasm1(SB)
MOV $1697, X7
JMP callbackasm1(SB)
MOV $1698, X7
JMP callbackasm1(SB)
MOV $1699, X7
JMP callbackasm1(SB)
MOV $1700, X7
JMP callbackasm1(SB)
MOV $1701, X7
JMP callbackasm1(SB)
MOV $1702, X7
JMP callbackasm1(SB)
MOV $1703, X7
JMP callbackasm1(SB)
MOV $1704, X7
JMP callbackasm1(SB)
MOV $1705, X7
JMP callbackasm1(SB)
MOV $1706, X7
JMP callbackasm1(SB)
MOV $1707, X7
JMP callbackasm1(SB)
MOV $1708, X7
JMP callbackasm1(SB)
MOV $1709, X7
JMP callbackasm1(SB)
MOV $1710, X7
JMP callbackasm1(SB)
MOV $1711, X7
JMP callbackasm1(SB)
MOV $1712, X7
JMP callbackasm1(SB)
MOV $1713, X7
JMP callbackasm1(SB)
MOV $1714, X7
JMP callbackasm1(SB)
MOV $1715, X7
JMP callbackasm1(SB)
MOV $1716, X7
JMP callbackasm1(SB)
MOV $1717, X7
JMP callbackasm1(SB)
MOV $1718, X7
JMP callbackasm1(SB)
MOV $1719, X7
JMP callbackasm1(SB)
MOV $1720, X7
JMP callbackasm1(SB)
MOV $1721, X7
JMP callbackasm1(SB)
MOV $1722, X7
JMP callbackasm1(SB)
MOV $1723, X7
JMP callbackasm1(SB)
MOV $1724, X7
JMP callbackasm1(SB)
MOV $1725, X7
JMP callbackasm1(SB)
MOV $1726, X7
JMP callbackasm1(SB)
MOV $1727, X7
JMP callbackasm1(SB)
MOV $1728, X7
JMP callbackasm1(SB)
MOV $1729, X7
JMP callbackasm1(SB)
MOV $1730, X7
JMP callbackasm1(SB)
MOV $1731, X7
JMP callbackasm1(SB)
MOV $1732, X7
JMP callbackasm1(SB)
MOV $1733, X7
JMP callbackasm1(SB)
MOV $1734, X7
JMP callbackasm1(SB)
MOV $1735, X7
JMP callbackasm1(SB)
MOV $1736, X7
JMP callbackasm1(SB)
MOV $1737, X7
JMP callbackasm1(SB)
MOV $1738, X7
JMP callbackasm1(SB)
MOV $1739, X7
JMP callbackasm1(SB)
MOV $1740, X7
JMP callbackasm1(SB)
MOV $1741, X7
JMP callbackasm1(SB)
MOV $1742, X7
JMP callbackasm1(SB)
MOV $1743, X7
JMP callbackasm1(SB)
MOV $1744, X7
JMP callbackasm1(SB)
MOV $1745, X7
JMP callbackasm1(SB)
MOV $1746, X7
JMP callbackasm1(SB)
MOV $1747, X7
JMP callbackasm1(SB)
MOV $1748, X7
JMP callbackasm1(SB)
MOV $1749, X7
JMP callbackasm1(SB)
MOV $1750, X7
JMP callbackasm1(SB)
MOV $1751, X7
JMP callbackasm1(SB)
MOV $1752, X7
JMP callbackasm1(SB)
MOV $1753, X7
JMP callbackasm1(SB)
MOV $1754, X7
JMP callbackasm1(SB)
MOV $1755, X7
JMP callbackasm1(SB)
MOV $1756, X7
JMP callbackasm1(SB)
MOV $1757, X7
JMP callbackasm1(SB)
MOV $1758, X7
JMP callbackasm1(SB)
MOV $1759, X7
JMP callbackasm1(SB)
MOV $1760, X7
JMP callbackasm1(SB)
MOV $1761, X7
JMP callbackasm1(SB)
MOV $1762, X7
JMP callbackasm1(SB)
MOV $1763, X7
JMP callbackasm1(SB)
MOV $1764, X7
JMP callbackasm1(SB)
MOV $1765, X7
JMP callbackasm1(SB)
MOV $1766, X7
JMP callbackasm1(SB)
MOV $1767, X7
JMP callbackasm1(SB)
MOV $1768, X7
JMP callbackasm1(SB)
MOV $1769, X7
JMP callbackasm1(SB)
MOV $1770, X7
JMP callbackasm1(SB)
MOV $1771, X7
JMP callbackasm1(SB)
MOV $1772, X7
JMP callbackasm1(SB)
MOV $1773, X7
JMP callbackasm1(SB)
MOV $1774, X7
JMP callbackasm1(SB)
MOV $1775, X7
JMP callbackasm1(SB)
MOV $1776, X7
JMP callbackasm1(SB)
MOV $1777, X7
JMP callbackasm1(SB)
MOV $1778, X7
JMP callbackasm1(SB)
MOV $1779, X7
JMP callbackasm1(SB)
MOV $1780, X7
JMP callbackasm1(SB)
MOV $1781, X7
JMP callbackasm1(SB)
MOV $1782, X7
JMP callbackasm1(SB)
MOV $1783, X7
JMP callbackasm1(SB)
MOV $1784, X7
JMP callbackasm1(SB)
MOV $1785, X7
JMP callbackasm1(SB)
MOV $1786, X7
JMP callbackasm1(SB)
MOV $1787, X7
JMP callbackasm1(SB)
MOV $1788, X7
JMP callbackasm1(SB)
MOV $1789, X7
JMP callbackasm1(SB)
MOV $1790, X7
JMP callbackasm1(SB)
MOV $1791, X7
JMP callbackasm1(SB)
MOV $1792, X7
JMP callbackasm1(SB)
MOV $1793, X7
JMP callbackasm1(SB)
MOV $1794, X7
JMP callbackasm1(SB)
MOV $1795, X7
JMP callbackasm1(SB)
MOV $1796, X7
JMP callbackasm1(SB)
MOV $1797, X7
JMP callbackasm1(SB)
MOV $1798, X7
JMP callbackasm1(SB)
MOV $1799, X7
JMP callbackasm1(SB)
MOV $1800, X7
JMP callbackasm1(SB)
MOV $1801, X7
JMP callbackasm1(SB)
MOV $1802, X7
JMP callbackasm1(SB)
MOV $1803, X7
JMP callbackasm1(SB)
MOV $1804, X7
JMP callbackasm1(SB)
MOV $1805, X7
JMP callbackasm1(SB)
MOV $1806, X7
JMP callbackasm1(SB)
MOV $1807, X7
JMP callbackasm1(SB)
MOV $1808, X7
JMP callbackasm1(SB)
MOV $1809, X7
JMP callbackasm1(SB)
MOV $1810, X7
JMP callbackasm1(SB)
MOV $1811, X7
JMP callbackasm1(SB)
MOV $1812, X7
JMP callbackasm1(SB)
MOV $1813, X7
JMP callbackasm1(SB)
MOV $1814, X7
JMP callbackasm1(SB)
MOV $1815, X7
JMP callbackasm1(SB)
MOV $1816, X7
JMP callbackasm1(SB)
MOV $1817, X7
JMP callbackasm1(SB)
MOV $1818, X7
JMP callbackasm1(SB)
MOV $1819, X7
JMP callbackasm1(SB)
MOV $1820, X7
JMP callbackasm1(SB)
MOV $1821, X7
JMP callbackasm1(SB)
MOV $1822, X7
JMP callbackasm1(SB)
MOV $1823, X7
JMP callbackasm1(SB)
MOV $1824, X7
JMP callbackasm1(SB)
MOV $1825, X7
JMP callbackasm1(SB)
MOV $1826, X7
JMP callbackasm1(SB)
MOV $1827, X7
JMP callbackasm1(SB)
MOV $1828, X7
JMP callbackasm1(SB)
MOV $1829, X7
JMP callbackasm1(SB)
MOV $1830, X7
JMP callbackasm1(SB)
MOV $1831, X7
JMP callbackasm1(SB)
MOV $1832, X7
JMP callbackasm1(SB)
MOV $1833, X7
JMP callbackasm1(SB)
MOV $1834, X7
JMP callbackasm1(SB)
MOV $1835, X7
JMP callbackasm1(SB)
MOV $1836, X7
JMP callbackasm1(SB)
MOV $1837, X7
JMP callbackasm1(SB)
MOV $1838, X7
JMP callbackasm1(SB)
MOV $1839, X7
JMP callbackasm1(SB)
MOV $1840, X7
JMP callbackasm1(SB)
MOV $1841, X7
JMP callbackasm1(SB)
MOV $1842, X7
JMP callbackasm1(SB)
MOV $1843, X7
JMP callbackasm1(SB)
MOV $1844, X7
JMP callbackasm1(SB)
MOV $1845, X7
JMP callbackasm1(SB)
MOV $1846, X7
JMP callbackasm1(SB)
MOV $1847, X7
JMP callbackasm1(SB)
MOV $1848, X7
JMP callbackasm1(SB)
MOV $1849, X7
JMP callbackasm1(SB)
MOV $1850, X7
JMP callbackasm1(SB)
MOV $1851, X7
JMP callbackasm1(SB)
MOV $1852, X7
JMP callbackasm1(SB)
MOV $1853, X7
JMP callbackasm1(SB)
MOV $1854, X7
JMP callbackasm1(SB)
MOV $1855, X7
JMP callbackasm1(SB)
MOV $1856, X7
JMP callbackasm1(SB)
MOV $1857, X7
JMP callbackasm1(SB)
MOV $1858, X7
JMP callbackasm1(SB)
MOV $1859, X7
JMP callbackasm1(SB)
MOV $1860, X7
JMP callbackasm1(SB)
MOV $1861, X7
JMP callbackasm1(SB)
MOV $1862, X7
JMP callbackasm1(SB)
MOV $1863, X7
JMP callbackasm1(SB)
MOV $1864, X7
JMP callbackasm1(SB)
MOV $1865, X7
JMP callbackasm1(SB)
MOV $1866, X7
JMP callbackasm1(SB)
MOV $1867, X7
JMP callbackasm1(SB)
MOV $1868, X7
JMP callbackasm1(SB)
MOV $1869, X7
JMP callbackasm1(SB)
MOV $1870, X7
JMP callbackasm1(SB)
MOV $1871, X7
JMP callbackasm1(SB)
MOV $1872, X7
JMP callbackasm1(SB)
MOV $1873, X7
JMP callbackasm1(SB)
MOV $1874, X7
JMP callbackasm1(SB)
MOV $1875, X7
JMP callbackasm1(SB)
MOV $1876, X7
JMP callbackasm1(SB)
MOV $1877, X7
JMP callbackasm1(SB)
MOV $1878, X7
JMP callbackasm1(SB)
MOV $1879, X7
JMP callbackasm1(SB)
MOV $1880, X7
JMP callbackasm1(SB)
MOV $1881, X7
JMP callbackasm1(SB)
MOV $1882, X7
JMP callbackasm1(SB)
MOV $1883, X7
JMP callbackasm1(SB)
MOV $1884, X7
JMP callbackasm1(SB)
MOV $1885, X7
JMP callbackasm1(SB)
MOV $1886, X7
JMP callbackasm1(SB)
MOV $1887, X7
JMP callbackasm1(SB)
MOV $1888, X7
JMP callbackasm1(SB)
MOV $1889, X7
JMP callbackasm1(SB)
MOV $1890, X7
JMP callbackasm1(SB)
MOV $1891, X7
JMP callbackasm1(SB)
MOV $1892, X7
JMP callbackasm1(SB)
MOV $1893, X7
JMP callbackasm1(SB)
MOV $1894, X7
JMP callbackasm1(SB)
MOV $1895, X7
JMP callbackasm1(SB)
MOV $1896, X7
JMP callbackasm1(SB)
MOV $1897, X7
JMP callbackasm1(SB)
MOV $1898, X7
JMP callbackasm1(SB)
MOV $1899, X7
JMP callbackasm1(SB)
MOV $1900, X7
JMP callbackasm1(SB)
MOV $1901, X7
JMP callbackasm1(SB)
MOV $1902, X7
JMP callbackasm1(SB)
MOV $1903, X7
JMP callbackasm1(SB)
MOV $1904, X7
JMP callbackasm1(SB)
MOV $1905, X7
JMP callbackasm1(SB)
MOV $1906, X7
JMP callbackasm1(SB)
MOV $1907, X7
JMP callbackasm1(SB)
MOV $1908, X7
JMP callbackasm1(SB)
MOV $1909, X7
JMP callbackasm1(SB)
MOV $1910, X7
JMP callbackasm1(SB)
MOV $1911, X7
JMP callbackasm1(SB)
MOV $1912, X7
JMP callbackasm1(SB)
MOV $1913, X7
JMP callbackasm1(SB)
MOV $1914, X7
JMP callbackasm1(SB)
MOV $1915, X7
JMP callbackasm1(SB)
MOV $1916, X7
JMP callbackasm1(SB)
MOV $1917, X7
JMP callbackasm1(SB)
MOV $1918, X7
JMP callbackasm1(SB)
MOV $1919, X7
JMP callbackasm1(SB)
MOV $1920, X7
JMP callbackasm1(SB)
MOV $1921, X7
JMP callbackasm1(SB)
MOV $1922, X7
JMP callbackasm1(SB)
MOV $1923, X7
JMP callbackasm1(SB)
MOV $1924, X7
JMP callbackasm1(SB)
MOV $1925, X7
JMP callbackasm1(SB)
MOV $1926, X7
JMP callbackasm1(SB)
MOV $1927, X7
JMP callbackasm1(SB)
MOV $1928, X7
JMP callbackasm1(SB)
MOV $1929, X7
JMP callbackasm1(SB)
MOV $1930, X7
JMP callbackasm1(SB)
MOV $1931, X7
JMP callbackasm1(SB)
MOV $1932, X7
JMP callbackasm1(SB)
MOV $1933, X7
JMP callbackasm1(SB)
MOV $1934, X7
JMP callbackasm1(SB)
MOV $1935, X7
JMP callbackasm1(SB)
MOV $1936, X7
JMP callbackasm1(SB)
MOV $1937, X7
JMP callbackasm1(SB)
MOV $1938, X7
JMP callbackasm1(SB)
MOV $1939, X7
JMP callbackasm1(SB)
MOV $1940, X7
JMP callbackasm1(SB)
MOV $1941, X7
JMP callbackasm1(SB)
MOV $1942, X7
JMP callbackasm1(SB)
MOV $1943, X7
JMP callbackasm1(SB)
MOV $1944, X7
JMP callbackasm1(SB)
MOV $1945, X7
JMP callbackasm1(SB)
MOV $1946, X7
JMP callbackasm1(SB)
MOV $1947, X7
JMP callbackasm1(SB)
MOV $1948, X7
JMP callbackasm1(SB)
MOV $1949, X7
JMP callbackasm1(SB)
MOV $1950, X7
JMP callbackasm1(SB)
MOV $1951, X7
JMP callbackasm1(SB)
MOV $1952, X7
JMP callbackasm1(SB)
MOV $1953, X7
JMP callbackasm1(SB)
MOV $1954, X7
JMP callbackasm1(SB)
MOV $1955, X7
JMP callbackasm1(SB)
MOV $1956, X7
JMP callbackasm1(SB)
MOV $1957, X7
JMP callbackasm1(SB)
MOV $1958, X7
JMP callbackasm1(SB)
MOV $1959, X7
JMP callbackasm1(SB)
MOV $1960, X7
JMP callbackasm1(SB)
MOV $1961, X7
JMP callbackasm1(SB)
MOV $1962, X7
JMP callbackasm1(SB)
MOV $1963, X7
JMP callbackasm1(SB)
MOV $1964, X7
JMP callbackasm1(SB)
MOV $1965, X7
JMP callbackasm1(SB)
MOV $1966, X7
JMP callbackasm1(SB)
MOV $1967, X7
JMP callbackasm1(SB)
MOV $1968, X7
JMP callbackasm1(SB)
MOV $1969, X7
JMP callbackasm1(SB)
MOV $1970, X7
JMP callbackasm1(SB)
MOV $1971, X7
JMP callbackasm1(SB)
MOV $1972, X7
JMP callbackasm1(SB)
MOV $1973, X7
JMP callbackasm1(SB)
MOV $1974, X7
JMP callbackasm1(SB)
MOV $1975, X7
JMP callbackasm1(SB)
MOV $1976, X7
JMP callbackasm1(SB)
MOV $1977, X7
JMP callbackasm1(SB)
MOV $1978, X7
JMP callbackasm1(SB)
MOV $1979, X7
JMP callbackasm1(SB)
MOV $1980, X7
JMP callbackasm1(SB)
MOV $1981, X7
JMP callbackasm1(SB)
MOV $1982, X7
JMP callbackasm1(SB)
MOV $1983, X7
JMP callbackasm1(SB)
MOV $1984, X7
JMP callbackasm1(SB)
MOV $1985, X7
JMP callbackasm1(SB)
MOV $1986, X7
JMP callbackasm1(SB)
MOV $1987, X7
JMP callbackasm1(SB)
MOV $1988, X7
JMP callbackasm1(SB)
MOV $1989, X7
JMP callbackasm1(SB)
MOV $1990, X7
JMP callbackasm1(SB)
MOV $1991, X7
JMP callbackasm1(SB)
MOV $1992, X7
JMP callbackasm1(SB)
MOV $1993, X7
JMP callbackasm1(SB)
MOV $1994, X7
JMP callbackasm1(SB)
MOV $1995, X7
JMP callbackasm1(SB)
MOV $1996, X7
JMP callbackasm1(SB)
MOV $1997, X7
JMP callbackasm1(SB)
MOV $1998, X7
JMP callbackasm1(SB)
MOV $1999, X7
JMP callbackasm1(SB)
golang-github-ebitengine-purego-0.10.1/zcallback_s390x.s 0000664 0000000 0000000 00000227360 15207302613 0023017 0 ustar 00root root 0000000 0000000 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
//go:build linux
// External code calls into callbackasm at an offset corresponding
// to the callback index. Callbackasm is a table of MOVD and BR instructions.
// The MOVD instruction loads R0 with the callback index, and the
// BR instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R0 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
// NOTE: We use R0 instead of R11 because R11 is callee-saved on S390X.
#include "textflag.h"
TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0
MOVD $0, R0
BR callbackasm1(SB)
MOVD $1, R0
BR callbackasm1(SB)
MOVD $2, R0
BR callbackasm1(SB)
MOVD $3, R0
BR callbackasm1(SB)
MOVD $4, R0
BR callbackasm1(SB)
MOVD $5, R0
BR callbackasm1(SB)
MOVD $6, R0
BR callbackasm1(SB)
MOVD $7, R0
BR callbackasm1(SB)
MOVD $8, R0
BR callbackasm1(SB)
MOVD $9, R0
BR callbackasm1(SB)
MOVD $10, R0
BR callbackasm1(SB)
MOVD $11, R0
BR callbackasm1(SB)
MOVD $12, R0
BR callbackasm1(SB)
MOVD $13, R0
BR callbackasm1(SB)
MOVD $14, R0
BR callbackasm1(SB)
MOVD $15, R0
BR callbackasm1(SB)
MOVD $16, R0
BR callbackasm1(SB)
MOVD $17, R0
BR callbackasm1(SB)
MOVD $18, R0
BR callbackasm1(SB)
MOVD $19, R0
BR callbackasm1(SB)
MOVD $20, R0
BR callbackasm1(SB)
MOVD $21, R0
BR callbackasm1(SB)
MOVD $22, R0
BR callbackasm1(SB)
MOVD $23, R0
BR callbackasm1(SB)
MOVD $24, R0
BR callbackasm1(SB)
MOVD $25, R0
BR callbackasm1(SB)
MOVD $26, R0
BR callbackasm1(SB)
MOVD $27, R0
BR callbackasm1(SB)
MOVD $28, R0
BR callbackasm1(SB)
MOVD $29, R0
BR callbackasm1(SB)
MOVD $30, R0
BR callbackasm1(SB)
MOVD $31, R0
BR callbackasm1(SB)
MOVD $32, R0
BR callbackasm1(SB)
MOVD $33, R0
BR callbackasm1(SB)
MOVD $34, R0
BR callbackasm1(SB)
MOVD $35, R0
BR callbackasm1(SB)
MOVD $36, R0
BR callbackasm1(SB)
MOVD $37, R0
BR callbackasm1(SB)
MOVD $38, R0
BR callbackasm1(SB)
MOVD $39, R0
BR callbackasm1(SB)
MOVD $40, R0
BR callbackasm1(SB)
MOVD $41, R0
BR callbackasm1(SB)
MOVD $42, R0
BR callbackasm1(SB)
MOVD $43, R0
BR callbackasm1(SB)
MOVD $44, R0
BR callbackasm1(SB)
MOVD $45, R0
BR callbackasm1(SB)
MOVD $46, R0
BR callbackasm1(SB)
MOVD $47, R0
BR callbackasm1(SB)
MOVD $48, R0
BR callbackasm1(SB)
MOVD $49, R0
BR callbackasm1(SB)
MOVD $50, R0
BR callbackasm1(SB)
MOVD $51, R0
BR callbackasm1(SB)
MOVD $52, R0
BR callbackasm1(SB)
MOVD $53, R0
BR callbackasm1(SB)
MOVD $54, R0
BR callbackasm1(SB)
MOVD $55, R0
BR callbackasm1(SB)
MOVD $56, R0
BR callbackasm1(SB)
MOVD $57, R0
BR callbackasm1(SB)
MOVD $58, R0
BR callbackasm1(SB)
MOVD $59, R0
BR callbackasm1(SB)
MOVD $60, R0
BR callbackasm1(SB)
MOVD $61, R0
BR callbackasm1(SB)
MOVD $62, R0
BR callbackasm1(SB)
MOVD $63, R0
BR callbackasm1(SB)
MOVD $64, R0
BR callbackasm1(SB)
MOVD $65, R0
BR callbackasm1(SB)
MOVD $66, R0
BR callbackasm1(SB)
MOVD $67, R0
BR callbackasm1(SB)
MOVD $68, R0
BR callbackasm1(SB)
MOVD $69, R0
BR callbackasm1(SB)
MOVD $70, R0
BR callbackasm1(SB)
MOVD $71, R0
BR callbackasm1(SB)
MOVD $72, R0
BR callbackasm1(SB)
MOVD $73, R0
BR callbackasm1(SB)
MOVD $74, R0
BR callbackasm1(SB)
MOVD $75, R0
BR callbackasm1(SB)
MOVD $76, R0
BR callbackasm1(SB)
MOVD $77, R0
BR callbackasm1(SB)
MOVD $78, R0
BR callbackasm1(SB)
MOVD $79, R0
BR callbackasm1(SB)
MOVD $80, R0
BR callbackasm1(SB)
MOVD $81, R0
BR callbackasm1(SB)
MOVD $82, R0
BR callbackasm1(SB)
MOVD $83, R0
BR callbackasm1(SB)
MOVD $84, R0
BR callbackasm1(SB)
MOVD $85, R0
BR callbackasm1(SB)
MOVD $86, R0
BR callbackasm1(SB)
MOVD $87, R0
BR callbackasm1(SB)
MOVD $88, R0
BR callbackasm1(SB)
MOVD $89, R0
BR callbackasm1(SB)
MOVD $90, R0
BR callbackasm1(SB)
MOVD $91, R0
BR callbackasm1(SB)
MOVD $92, R0
BR callbackasm1(SB)
MOVD $93, R0
BR callbackasm1(SB)
MOVD $94, R0
BR callbackasm1(SB)
MOVD $95, R0
BR callbackasm1(SB)
MOVD $96, R0
BR callbackasm1(SB)
MOVD $97, R0
BR callbackasm1(SB)
MOVD $98, R0
BR callbackasm1(SB)
MOVD $99, R0
BR callbackasm1(SB)
MOVD $100, R0
BR callbackasm1(SB)
MOVD $101, R0
BR callbackasm1(SB)
MOVD $102, R0
BR callbackasm1(SB)
MOVD $103, R0
BR callbackasm1(SB)
MOVD $104, R0
BR callbackasm1(SB)
MOVD $105, R0
BR callbackasm1(SB)
MOVD $106, R0
BR callbackasm1(SB)
MOVD $107, R0
BR callbackasm1(SB)
MOVD $108, R0
BR callbackasm1(SB)
MOVD $109, R0
BR callbackasm1(SB)
MOVD $110, R0
BR callbackasm1(SB)
MOVD $111, R0
BR callbackasm1(SB)
MOVD $112, R0
BR callbackasm1(SB)
MOVD $113, R0
BR callbackasm1(SB)
MOVD $114, R0
BR callbackasm1(SB)
MOVD $115, R0
BR callbackasm1(SB)
MOVD $116, R0
BR callbackasm1(SB)
MOVD $117, R0
BR callbackasm1(SB)
MOVD $118, R0
BR callbackasm1(SB)
MOVD $119, R0
BR callbackasm1(SB)
MOVD $120, R0
BR callbackasm1(SB)
MOVD $121, R0
BR callbackasm1(SB)
MOVD $122, R0
BR callbackasm1(SB)
MOVD $123, R0
BR callbackasm1(SB)
MOVD $124, R0
BR callbackasm1(SB)
MOVD $125, R0
BR callbackasm1(SB)
MOVD $126, R0
BR callbackasm1(SB)
MOVD $127, R0
BR callbackasm1(SB)
MOVD $128, R0
BR callbackasm1(SB)
MOVD $129, R0
BR callbackasm1(SB)
MOVD $130, R0
BR callbackasm1(SB)
MOVD $131, R0
BR callbackasm1(SB)
MOVD $132, R0
BR callbackasm1(SB)
MOVD $133, R0
BR callbackasm1(SB)
MOVD $134, R0
BR callbackasm1(SB)
MOVD $135, R0
BR callbackasm1(SB)
MOVD $136, R0
BR callbackasm1(SB)
MOVD $137, R0
BR callbackasm1(SB)
MOVD $138, R0
BR callbackasm1(SB)
MOVD $139, R0
BR callbackasm1(SB)
MOVD $140, R0
BR callbackasm1(SB)
MOVD $141, R0
BR callbackasm1(SB)
MOVD $142, R0
BR callbackasm1(SB)
MOVD $143, R0
BR callbackasm1(SB)
MOVD $144, R0
BR callbackasm1(SB)
MOVD $145, R0
BR callbackasm1(SB)
MOVD $146, R0
BR callbackasm1(SB)
MOVD $147, R0
BR callbackasm1(SB)
MOVD $148, R0
BR callbackasm1(SB)
MOVD $149, R0
BR callbackasm1(SB)
MOVD $150, R0
BR callbackasm1(SB)
MOVD $151, R0
BR callbackasm1(SB)
MOVD $152, R0
BR callbackasm1(SB)
MOVD $153, R0
BR callbackasm1(SB)
MOVD $154, R0
BR callbackasm1(SB)
MOVD $155, R0
BR callbackasm1(SB)
MOVD $156, R0
BR callbackasm1(SB)
MOVD $157, R0
BR callbackasm1(SB)
MOVD $158, R0
BR callbackasm1(SB)
MOVD $159, R0
BR callbackasm1(SB)
MOVD $160, R0
BR callbackasm1(SB)
MOVD $161, R0
BR callbackasm1(SB)
MOVD $162, R0
BR callbackasm1(SB)
MOVD $163, R0
BR callbackasm1(SB)
MOVD $164, R0
BR callbackasm1(SB)
MOVD $165, R0
BR callbackasm1(SB)
MOVD $166, R0
BR callbackasm1(SB)
MOVD $167, R0
BR callbackasm1(SB)
MOVD $168, R0
BR callbackasm1(SB)
MOVD $169, R0
BR callbackasm1(SB)
MOVD $170, R0
BR callbackasm1(SB)
MOVD $171, R0
BR callbackasm1(SB)
MOVD $172, R0
BR callbackasm1(SB)
MOVD $173, R0
BR callbackasm1(SB)
MOVD $174, R0
BR callbackasm1(SB)
MOVD $175, R0
BR callbackasm1(SB)
MOVD $176, R0
BR callbackasm1(SB)
MOVD $177, R0
BR callbackasm1(SB)
MOVD $178, R0
BR callbackasm1(SB)
MOVD $179, R0
BR callbackasm1(SB)
MOVD $180, R0
BR callbackasm1(SB)
MOVD $181, R0
BR callbackasm1(SB)
MOVD $182, R0
BR callbackasm1(SB)
MOVD $183, R0
BR callbackasm1(SB)
MOVD $184, R0
BR callbackasm1(SB)
MOVD $185, R0
BR callbackasm1(SB)
MOVD $186, R0
BR callbackasm1(SB)
MOVD $187, R0
BR callbackasm1(SB)
MOVD $188, R0
BR callbackasm1(SB)
MOVD $189, R0
BR callbackasm1(SB)
MOVD $190, R0
BR callbackasm1(SB)
MOVD $191, R0
BR callbackasm1(SB)
MOVD $192, R0
BR callbackasm1(SB)
MOVD $193, R0
BR callbackasm1(SB)
MOVD $194, R0
BR callbackasm1(SB)
MOVD $195, R0
BR callbackasm1(SB)
MOVD $196, R0
BR callbackasm1(SB)
MOVD $197, R0
BR callbackasm1(SB)
MOVD $198, R0
BR callbackasm1(SB)
MOVD $199, R0
BR callbackasm1(SB)
MOVD $200, R0
BR callbackasm1(SB)
MOVD $201, R0
BR callbackasm1(SB)
MOVD $202, R0
BR callbackasm1(SB)
MOVD $203, R0
BR callbackasm1(SB)
MOVD $204, R0
BR callbackasm1(SB)
MOVD $205, R0
BR callbackasm1(SB)
MOVD $206, R0
BR callbackasm1(SB)
MOVD $207, R0
BR callbackasm1(SB)
MOVD $208, R0
BR callbackasm1(SB)
MOVD $209, R0
BR callbackasm1(SB)
MOVD $210, R0
BR callbackasm1(SB)
MOVD $211, R0
BR callbackasm1(SB)
MOVD $212, R0
BR callbackasm1(SB)
MOVD $213, R0
BR callbackasm1(SB)
MOVD $214, R0
BR callbackasm1(SB)
MOVD $215, R0
BR callbackasm1(SB)
MOVD $216, R0
BR callbackasm1(SB)
MOVD $217, R0
BR callbackasm1(SB)
MOVD $218, R0
BR callbackasm1(SB)
MOVD $219, R0
BR callbackasm1(SB)
MOVD $220, R0
BR callbackasm1(SB)
MOVD $221, R0
BR callbackasm1(SB)
MOVD $222, R0
BR callbackasm1(SB)
MOVD $223, R0
BR callbackasm1(SB)
MOVD $224, R0
BR callbackasm1(SB)
MOVD $225, R0
BR callbackasm1(SB)
MOVD $226, R0
BR callbackasm1(SB)
MOVD $227, R0
BR callbackasm1(SB)
MOVD $228, R0
BR callbackasm1(SB)
MOVD $229, R0
BR callbackasm1(SB)
MOVD $230, R0
BR callbackasm1(SB)
MOVD $231, R0
BR callbackasm1(SB)
MOVD $232, R0
BR callbackasm1(SB)
MOVD $233, R0
BR callbackasm1(SB)
MOVD $234, R0
BR callbackasm1(SB)
MOVD $235, R0
BR callbackasm1(SB)
MOVD $236, R0
BR callbackasm1(SB)
MOVD $237, R0
BR callbackasm1(SB)
MOVD $238, R0
BR callbackasm1(SB)
MOVD $239, R0
BR callbackasm1(SB)
MOVD $240, R0
BR callbackasm1(SB)
MOVD $241, R0
BR callbackasm1(SB)
MOVD $242, R0
BR callbackasm1(SB)
MOVD $243, R0
BR callbackasm1(SB)
MOVD $244, R0
BR callbackasm1(SB)
MOVD $245, R0
BR callbackasm1(SB)
MOVD $246, R0
BR callbackasm1(SB)
MOVD $247, R0
BR callbackasm1(SB)
MOVD $248, R0
BR callbackasm1(SB)
MOVD $249, R0
BR callbackasm1(SB)
MOVD $250, R0
BR callbackasm1(SB)
MOVD $251, R0
BR callbackasm1(SB)
MOVD $252, R0
BR callbackasm1(SB)
MOVD $253, R0
BR callbackasm1(SB)
MOVD $254, R0
BR callbackasm1(SB)
MOVD $255, R0
BR callbackasm1(SB)
MOVD $256, R0
BR callbackasm1(SB)
MOVD $257, R0
BR callbackasm1(SB)
MOVD $258, R0
BR callbackasm1(SB)
MOVD $259, R0
BR callbackasm1(SB)
MOVD $260, R0
BR callbackasm1(SB)
MOVD $261, R0
BR callbackasm1(SB)
MOVD $262, R0
BR callbackasm1(SB)
MOVD $263, R0
BR callbackasm1(SB)
MOVD $264, R0
BR callbackasm1(SB)
MOVD $265, R0
BR callbackasm1(SB)
MOVD $266, R0
BR callbackasm1(SB)
MOVD $267, R0
BR callbackasm1(SB)
MOVD $268, R0
BR callbackasm1(SB)
MOVD $269, R0
BR callbackasm1(SB)
MOVD $270, R0
BR callbackasm1(SB)
MOVD $271, R0
BR callbackasm1(SB)
MOVD $272, R0
BR callbackasm1(SB)
MOVD $273, R0
BR callbackasm1(SB)
MOVD $274, R0
BR callbackasm1(SB)
MOVD $275, R0
BR callbackasm1(SB)
MOVD $276, R0
BR callbackasm1(SB)
MOVD $277, R0
BR callbackasm1(SB)
MOVD $278, R0
BR callbackasm1(SB)
MOVD $279, R0
BR callbackasm1(SB)
MOVD $280, R0
BR callbackasm1(SB)
MOVD $281, R0
BR callbackasm1(SB)
MOVD $282, R0
BR callbackasm1(SB)
MOVD $283, R0
BR callbackasm1(SB)
MOVD $284, R0
BR callbackasm1(SB)
MOVD $285, R0
BR callbackasm1(SB)
MOVD $286, R0
BR callbackasm1(SB)
MOVD $287, R0
BR callbackasm1(SB)
MOVD $288, R0
BR callbackasm1(SB)
MOVD $289, R0
BR callbackasm1(SB)
MOVD $290, R0
BR callbackasm1(SB)
MOVD $291, R0
BR callbackasm1(SB)
MOVD $292, R0
BR callbackasm1(SB)
MOVD $293, R0
BR callbackasm1(SB)
MOVD $294, R0
BR callbackasm1(SB)
MOVD $295, R0
BR callbackasm1(SB)
MOVD $296, R0
BR callbackasm1(SB)
MOVD $297, R0
BR callbackasm1(SB)
MOVD $298, R0
BR callbackasm1(SB)
MOVD $299, R0
BR callbackasm1(SB)
MOVD $300, R0
BR callbackasm1(SB)
MOVD $301, R0
BR callbackasm1(SB)
MOVD $302, R0
BR callbackasm1(SB)
MOVD $303, R0
BR callbackasm1(SB)
MOVD $304, R0
BR callbackasm1(SB)
MOVD $305, R0
BR callbackasm1(SB)
MOVD $306, R0
BR callbackasm1(SB)
MOVD $307, R0
BR callbackasm1(SB)
MOVD $308, R0
BR callbackasm1(SB)
MOVD $309, R0
BR callbackasm1(SB)
MOVD $310, R0
BR callbackasm1(SB)
MOVD $311, R0
BR callbackasm1(SB)
MOVD $312, R0
BR callbackasm1(SB)
MOVD $313, R0
BR callbackasm1(SB)
MOVD $314, R0
BR callbackasm1(SB)
MOVD $315, R0
BR callbackasm1(SB)
MOVD $316, R0
BR callbackasm1(SB)
MOVD $317, R0
BR callbackasm1(SB)
MOVD $318, R0
BR callbackasm1(SB)
MOVD $319, R0
BR callbackasm1(SB)
MOVD $320, R0
BR callbackasm1(SB)
MOVD $321, R0
BR callbackasm1(SB)
MOVD $322, R0
BR callbackasm1(SB)
MOVD $323, R0
BR callbackasm1(SB)
MOVD $324, R0
BR callbackasm1(SB)
MOVD $325, R0
BR callbackasm1(SB)
MOVD $326, R0
BR callbackasm1(SB)
MOVD $327, R0
BR callbackasm1(SB)
MOVD $328, R0
BR callbackasm1(SB)
MOVD $329, R0
BR callbackasm1(SB)
MOVD $330, R0
BR callbackasm1(SB)
MOVD $331, R0
BR callbackasm1(SB)
MOVD $332, R0
BR callbackasm1(SB)
MOVD $333, R0
BR callbackasm1(SB)
MOVD $334, R0
BR callbackasm1(SB)
MOVD $335, R0
BR callbackasm1(SB)
MOVD $336, R0
BR callbackasm1(SB)
MOVD $337, R0
BR callbackasm1(SB)
MOVD $338, R0
BR callbackasm1(SB)
MOVD $339, R0
BR callbackasm1(SB)
MOVD $340, R0
BR callbackasm1(SB)
MOVD $341, R0
BR callbackasm1(SB)
MOVD $342, R0
BR callbackasm1(SB)
MOVD $343, R0
BR callbackasm1(SB)
MOVD $344, R0
BR callbackasm1(SB)
MOVD $345, R0
BR callbackasm1(SB)
MOVD $346, R0
BR callbackasm1(SB)
MOVD $347, R0
BR callbackasm1(SB)
MOVD $348, R0
BR callbackasm1(SB)
MOVD $349, R0
BR callbackasm1(SB)
MOVD $350, R0
BR callbackasm1(SB)
MOVD $351, R0
BR callbackasm1(SB)
MOVD $352, R0
BR callbackasm1(SB)
MOVD $353, R0
BR callbackasm1(SB)
MOVD $354, R0
BR callbackasm1(SB)
MOVD $355, R0
BR callbackasm1(SB)
MOVD $356, R0
BR callbackasm1(SB)
MOVD $357, R0
BR callbackasm1(SB)
MOVD $358, R0
BR callbackasm1(SB)
MOVD $359, R0
BR callbackasm1(SB)
MOVD $360, R0
BR callbackasm1(SB)
MOVD $361, R0
BR callbackasm1(SB)
MOVD $362, R0
BR callbackasm1(SB)
MOVD $363, R0
BR callbackasm1(SB)
MOVD $364, R0
BR callbackasm1(SB)
MOVD $365, R0
BR callbackasm1(SB)
MOVD $366, R0
BR callbackasm1(SB)
MOVD $367, R0
BR callbackasm1(SB)
MOVD $368, R0
BR callbackasm1(SB)
MOVD $369, R0
BR callbackasm1(SB)
MOVD $370, R0
BR callbackasm1(SB)
MOVD $371, R0
BR callbackasm1(SB)
MOVD $372, R0
BR callbackasm1(SB)
MOVD $373, R0
BR callbackasm1(SB)
MOVD $374, R0
BR callbackasm1(SB)
MOVD $375, R0
BR callbackasm1(SB)
MOVD $376, R0
BR callbackasm1(SB)
MOVD $377, R0
BR callbackasm1(SB)
MOVD $378, R0
BR callbackasm1(SB)
MOVD $379, R0
BR callbackasm1(SB)
MOVD $380, R0
BR callbackasm1(SB)
MOVD $381, R0
BR callbackasm1(SB)
MOVD $382, R0
BR callbackasm1(SB)
MOVD $383, R0
BR callbackasm1(SB)
MOVD $384, R0
BR callbackasm1(SB)
MOVD $385, R0
BR callbackasm1(SB)
MOVD $386, R0
BR callbackasm1(SB)
MOVD $387, R0
BR callbackasm1(SB)
MOVD $388, R0
BR callbackasm1(SB)
MOVD $389, R0
BR callbackasm1(SB)
MOVD $390, R0
BR callbackasm1(SB)
MOVD $391, R0
BR callbackasm1(SB)
MOVD $392, R0
BR callbackasm1(SB)
MOVD $393, R0
BR callbackasm1(SB)
MOVD $394, R0
BR callbackasm1(SB)
MOVD $395, R0
BR callbackasm1(SB)
MOVD $396, R0
BR callbackasm1(SB)
MOVD $397, R0
BR callbackasm1(SB)
MOVD $398, R0
BR callbackasm1(SB)
MOVD $399, R0
BR callbackasm1(SB)
MOVD $400, R0
BR callbackasm1(SB)
MOVD $401, R0
BR callbackasm1(SB)
MOVD $402, R0
BR callbackasm1(SB)
MOVD $403, R0
BR callbackasm1(SB)
MOVD $404, R0
BR callbackasm1(SB)
MOVD $405, R0
BR callbackasm1(SB)
MOVD $406, R0
BR callbackasm1(SB)
MOVD $407, R0
BR callbackasm1(SB)
MOVD $408, R0
BR callbackasm1(SB)
MOVD $409, R0
BR callbackasm1(SB)
MOVD $410, R0
BR callbackasm1(SB)
MOVD $411, R0
BR callbackasm1(SB)
MOVD $412, R0
BR callbackasm1(SB)
MOVD $413, R0
BR callbackasm1(SB)
MOVD $414, R0
BR callbackasm1(SB)
MOVD $415, R0
BR callbackasm1(SB)
MOVD $416, R0
BR callbackasm1(SB)
MOVD $417, R0
BR callbackasm1(SB)
MOVD $418, R0
BR callbackasm1(SB)
MOVD $419, R0
BR callbackasm1(SB)
MOVD $420, R0
BR callbackasm1(SB)
MOVD $421, R0
BR callbackasm1(SB)
MOVD $422, R0
BR callbackasm1(SB)
MOVD $423, R0
BR callbackasm1(SB)
MOVD $424, R0
BR callbackasm1(SB)
MOVD $425, R0
BR callbackasm1(SB)
MOVD $426, R0
BR callbackasm1(SB)
MOVD $427, R0
BR callbackasm1(SB)
MOVD $428, R0
BR callbackasm1(SB)
MOVD $429, R0
BR callbackasm1(SB)
MOVD $430, R0
BR callbackasm1(SB)
MOVD $431, R0
BR callbackasm1(SB)
MOVD $432, R0
BR callbackasm1(SB)
MOVD $433, R0
BR callbackasm1(SB)
MOVD $434, R0
BR callbackasm1(SB)
MOVD $435, R0
BR callbackasm1(SB)
MOVD $436, R0
BR callbackasm1(SB)
MOVD $437, R0
BR callbackasm1(SB)
MOVD $438, R0
BR callbackasm1(SB)
MOVD $439, R0
BR callbackasm1(SB)
MOVD $440, R0
BR callbackasm1(SB)
MOVD $441, R0
BR callbackasm1(SB)
MOVD $442, R0
BR callbackasm1(SB)
MOVD $443, R0
BR callbackasm1(SB)
MOVD $444, R0
BR callbackasm1(SB)
MOVD $445, R0
BR callbackasm1(SB)
MOVD $446, R0
BR callbackasm1(SB)
MOVD $447, R0
BR callbackasm1(SB)
MOVD $448, R0
BR callbackasm1(SB)
MOVD $449, R0
BR callbackasm1(SB)
MOVD $450, R0
BR callbackasm1(SB)
MOVD $451, R0
BR callbackasm1(SB)
MOVD $452, R0
BR callbackasm1(SB)
MOVD $453, R0
BR callbackasm1(SB)
MOVD $454, R0
BR callbackasm1(SB)
MOVD $455, R0
BR callbackasm1(SB)
MOVD $456, R0
BR callbackasm1(SB)
MOVD $457, R0
BR callbackasm1(SB)
MOVD $458, R0
BR callbackasm1(SB)
MOVD $459, R0
BR callbackasm1(SB)
MOVD $460, R0
BR callbackasm1(SB)
MOVD $461, R0
BR callbackasm1(SB)
MOVD $462, R0
BR callbackasm1(SB)
MOVD $463, R0
BR callbackasm1(SB)
MOVD $464, R0
BR callbackasm1(SB)
MOVD $465, R0
BR callbackasm1(SB)
MOVD $466, R0
BR callbackasm1(SB)
MOVD $467, R0
BR callbackasm1(SB)
MOVD $468, R0
BR callbackasm1(SB)
MOVD $469, R0
BR callbackasm1(SB)
MOVD $470, R0
BR callbackasm1(SB)
MOVD $471, R0
BR callbackasm1(SB)
MOVD $472, R0
BR callbackasm1(SB)
MOVD $473, R0
BR callbackasm1(SB)
MOVD $474, R0
BR callbackasm1(SB)
MOVD $475, R0
BR callbackasm1(SB)
MOVD $476, R0
BR callbackasm1(SB)
MOVD $477, R0
BR callbackasm1(SB)
MOVD $478, R0
BR callbackasm1(SB)
MOVD $479, R0
BR callbackasm1(SB)
MOVD $480, R0
BR callbackasm1(SB)
MOVD $481, R0
BR callbackasm1(SB)
MOVD $482, R0
BR callbackasm1(SB)
MOVD $483, R0
BR callbackasm1(SB)
MOVD $484, R0
BR callbackasm1(SB)
MOVD $485, R0
BR callbackasm1(SB)
MOVD $486, R0
BR callbackasm1(SB)
MOVD $487, R0
BR callbackasm1(SB)
MOVD $488, R0
BR callbackasm1(SB)
MOVD $489, R0
BR callbackasm1(SB)
MOVD $490, R0
BR callbackasm1(SB)
MOVD $491, R0
BR callbackasm1(SB)
MOVD $492, R0
BR callbackasm1(SB)
MOVD $493, R0
BR callbackasm1(SB)
MOVD $494, R0
BR callbackasm1(SB)
MOVD $495, R0
BR callbackasm1(SB)
MOVD $496, R0
BR callbackasm1(SB)
MOVD $497, R0
BR callbackasm1(SB)
MOVD $498, R0
BR callbackasm1(SB)
MOVD $499, R0
BR callbackasm1(SB)
MOVD $500, R0
BR callbackasm1(SB)
MOVD $501, R0
BR callbackasm1(SB)
MOVD $502, R0
BR callbackasm1(SB)
MOVD $503, R0
BR callbackasm1(SB)
MOVD $504, R0
BR callbackasm1(SB)
MOVD $505, R0
BR callbackasm1(SB)
MOVD $506, R0
BR callbackasm1(SB)
MOVD $507, R0
BR callbackasm1(SB)
MOVD $508, R0
BR callbackasm1(SB)
MOVD $509, R0
BR callbackasm1(SB)
MOVD $510, R0
BR callbackasm1(SB)
MOVD $511, R0
BR callbackasm1(SB)
MOVD $512, R0
BR callbackasm1(SB)
MOVD $513, R0
BR callbackasm1(SB)
MOVD $514, R0
BR callbackasm1(SB)
MOVD $515, R0
BR callbackasm1(SB)
MOVD $516, R0
BR callbackasm1(SB)
MOVD $517, R0
BR callbackasm1(SB)
MOVD $518, R0
BR callbackasm1(SB)
MOVD $519, R0
BR callbackasm1(SB)
MOVD $520, R0
BR callbackasm1(SB)
MOVD $521, R0
BR callbackasm1(SB)
MOVD $522, R0
BR callbackasm1(SB)
MOVD $523, R0
BR callbackasm1(SB)
MOVD $524, R0
BR callbackasm1(SB)
MOVD $525, R0
BR callbackasm1(SB)
MOVD $526, R0
BR callbackasm1(SB)
MOVD $527, R0
BR callbackasm1(SB)
MOVD $528, R0
BR callbackasm1(SB)
MOVD $529, R0
BR callbackasm1(SB)
MOVD $530, R0
BR callbackasm1(SB)
MOVD $531, R0
BR callbackasm1(SB)
MOVD $532, R0
BR callbackasm1(SB)
MOVD $533, R0
BR callbackasm1(SB)
MOVD $534, R0
BR callbackasm1(SB)
MOVD $535, R0
BR callbackasm1(SB)
MOVD $536, R0
BR callbackasm1(SB)
MOVD $537, R0
BR callbackasm1(SB)
MOVD $538, R0
BR callbackasm1(SB)
MOVD $539, R0
BR callbackasm1(SB)
MOVD $540, R0
BR callbackasm1(SB)
MOVD $541, R0
BR callbackasm1(SB)
MOVD $542, R0
BR callbackasm1(SB)
MOVD $543, R0
BR callbackasm1(SB)
MOVD $544, R0
BR callbackasm1(SB)
MOVD $545, R0
BR callbackasm1(SB)
MOVD $546, R0
BR callbackasm1(SB)
MOVD $547, R0
BR callbackasm1(SB)
MOVD $548, R0
BR callbackasm1(SB)
MOVD $549, R0
BR callbackasm1(SB)
MOVD $550, R0
BR callbackasm1(SB)
MOVD $551, R0
BR callbackasm1(SB)
MOVD $552, R0
BR callbackasm1(SB)
MOVD $553, R0
BR callbackasm1(SB)
MOVD $554, R0
BR callbackasm1(SB)
MOVD $555, R0
BR callbackasm1(SB)
MOVD $556, R0
BR callbackasm1(SB)
MOVD $557, R0
BR callbackasm1(SB)
MOVD $558, R0
BR callbackasm1(SB)
MOVD $559, R0
BR callbackasm1(SB)
MOVD $560, R0
BR callbackasm1(SB)
MOVD $561, R0
BR callbackasm1(SB)
MOVD $562, R0
BR callbackasm1(SB)
MOVD $563, R0
BR callbackasm1(SB)
MOVD $564, R0
BR callbackasm1(SB)
MOVD $565, R0
BR callbackasm1(SB)
MOVD $566, R0
BR callbackasm1(SB)
MOVD $567, R0
BR callbackasm1(SB)
MOVD $568, R0
BR callbackasm1(SB)
MOVD $569, R0
BR callbackasm1(SB)
MOVD $570, R0
BR callbackasm1(SB)
MOVD $571, R0
BR callbackasm1(SB)
MOVD $572, R0
BR callbackasm1(SB)
MOVD $573, R0
BR callbackasm1(SB)
MOVD $574, R0
BR callbackasm1(SB)
MOVD $575, R0
BR callbackasm1(SB)
MOVD $576, R0
BR callbackasm1(SB)
MOVD $577, R0
BR callbackasm1(SB)
MOVD $578, R0
BR callbackasm1(SB)
MOVD $579, R0
BR callbackasm1(SB)
MOVD $580, R0
BR callbackasm1(SB)
MOVD $581, R0
BR callbackasm1(SB)
MOVD $582, R0
BR callbackasm1(SB)
MOVD $583, R0
BR callbackasm1(SB)
MOVD $584, R0
BR callbackasm1(SB)
MOVD $585, R0
BR callbackasm1(SB)
MOVD $586, R0
BR callbackasm1(SB)
MOVD $587, R0
BR callbackasm1(SB)
MOVD $588, R0
BR callbackasm1(SB)
MOVD $589, R0
BR callbackasm1(SB)
MOVD $590, R0
BR callbackasm1(SB)
MOVD $591, R0
BR callbackasm1(SB)
MOVD $592, R0
BR callbackasm1(SB)
MOVD $593, R0
BR callbackasm1(SB)
MOVD $594, R0
BR callbackasm1(SB)
MOVD $595, R0
BR callbackasm1(SB)
MOVD $596, R0
BR callbackasm1(SB)
MOVD $597, R0
BR callbackasm1(SB)
MOVD $598, R0
BR callbackasm1(SB)
MOVD $599, R0
BR callbackasm1(SB)
MOVD $600, R0
BR callbackasm1(SB)
MOVD $601, R0
BR callbackasm1(SB)
MOVD $602, R0
BR callbackasm1(SB)
MOVD $603, R0
BR callbackasm1(SB)
MOVD $604, R0
BR callbackasm1(SB)
MOVD $605, R0
BR callbackasm1(SB)
MOVD $606, R0
BR callbackasm1(SB)
MOVD $607, R0
BR callbackasm1(SB)
MOVD $608, R0
BR callbackasm1(SB)
MOVD $609, R0
BR callbackasm1(SB)
MOVD $610, R0
BR callbackasm1(SB)
MOVD $611, R0
BR callbackasm1(SB)
MOVD $612, R0
BR callbackasm1(SB)
MOVD $613, R0
BR callbackasm1(SB)
MOVD $614, R0
BR callbackasm1(SB)
MOVD $615, R0
BR callbackasm1(SB)
MOVD $616, R0
BR callbackasm1(SB)
MOVD $617, R0
BR callbackasm1(SB)
MOVD $618, R0
BR callbackasm1(SB)
MOVD $619, R0
BR callbackasm1(SB)
MOVD $620, R0
BR callbackasm1(SB)
MOVD $621, R0
BR callbackasm1(SB)
MOVD $622, R0
BR callbackasm1(SB)
MOVD $623, R0
BR callbackasm1(SB)
MOVD $624, R0
BR callbackasm1(SB)
MOVD $625, R0
BR callbackasm1(SB)
MOVD $626, R0
BR callbackasm1(SB)
MOVD $627, R0
BR callbackasm1(SB)
MOVD $628, R0
BR callbackasm1(SB)
MOVD $629, R0
BR callbackasm1(SB)
MOVD $630, R0
BR callbackasm1(SB)
MOVD $631, R0
BR callbackasm1(SB)
MOVD $632, R0
BR callbackasm1(SB)
MOVD $633, R0
BR callbackasm1(SB)
MOVD $634, R0
BR callbackasm1(SB)
MOVD $635, R0
BR callbackasm1(SB)
MOVD $636, R0
BR callbackasm1(SB)
MOVD $637, R0
BR callbackasm1(SB)
MOVD $638, R0
BR callbackasm1(SB)
MOVD $639, R0
BR callbackasm1(SB)
MOVD $640, R0
BR callbackasm1(SB)
MOVD $641, R0
BR callbackasm1(SB)
MOVD $642, R0
BR callbackasm1(SB)
MOVD $643, R0
BR callbackasm1(SB)
MOVD $644, R0
BR callbackasm1(SB)
MOVD $645, R0
BR callbackasm1(SB)
MOVD $646, R0
BR callbackasm1(SB)
MOVD $647, R0
BR callbackasm1(SB)
MOVD $648, R0
BR callbackasm1(SB)
MOVD $649, R0
BR callbackasm1(SB)
MOVD $650, R0
BR callbackasm1(SB)
MOVD $651, R0
BR callbackasm1(SB)
MOVD $652, R0
BR callbackasm1(SB)
MOVD $653, R0
BR callbackasm1(SB)
MOVD $654, R0
BR callbackasm1(SB)
MOVD $655, R0
BR callbackasm1(SB)
MOVD $656, R0
BR callbackasm1(SB)
MOVD $657, R0
BR callbackasm1(SB)
MOVD $658, R0
BR callbackasm1(SB)
MOVD $659, R0
BR callbackasm1(SB)
MOVD $660, R0
BR callbackasm1(SB)
MOVD $661, R0
BR callbackasm1(SB)
MOVD $662, R0
BR callbackasm1(SB)
MOVD $663, R0
BR callbackasm1(SB)
MOVD $664, R0
BR callbackasm1(SB)
MOVD $665, R0
BR callbackasm1(SB)
MOVD $666, R0
BR callbackasm1(SB)
MOVD $667, R0
BR callbackasm1(SB)
MOVD $668, R0
BR callbackasm1(SB)
MOVD $669, R0
BR callbackasm1(SB)
MOVD $670, R0
BR callbackasm1(SB)
MOVD $671, R0
BR callbackasm1(SB)
MOVD $672, R0
BR callbackasm1(SB)
MOVD $673, R0
BR callbackasm1(SB)
MOVD $674, R0
BR callbackasm1(SB)
MOVD $675, R0
BR callbackasm1(SB)
MOVD $676, R0
BR callbackasm1(SB)
MOVD $677, R0
BR callbackasm1(SB)
MOVD $678, R0
BR callbackasm1(SB)
MOVD $679, R0
BR callbackasm1(SB)
MOVD $680, R0
BR callbackasm1(SB)
MOVD $681, R0
BR callbackasm1(SB)
MOVD $682, R0
BR callbackasm1(SB)
MOVD $683, R0
BR callbackasm1(SB)
MOVD $684, R0
BR callbackasm1(SB)
MOVD $685, R0
BR callbackasm1(SB)
MOVD $686, R0
BR callbackasm1(SB)
MOVD $687, R0
BR callbackasm1(SB)
MOVD $688, R0
BR callbackasm1(SB)
MOVD $689, R0
BR callbackasm1(SB)
MOVD $690, R0
BR callbackasm1(SB)
MOVD $691, R0
BR callbackasm1(SB)
MOVD $692, R0
BR callbackasm1(SB)
MOVD $693, R0
BR callbackasm1(SB)
MOVD $694, R0
BR callbackasm1(SB)
MOVD $695, R0
BR callbackasm1(SB)
MOVD $696, R0
BR callbackasm1(SB)
MOVD $697, R0
BR callbackasm1(SB)
MOVD $698, R0
BR callbackasm1(SB)
MOVD $699, R0
BR callbackasm1(SB)
MOVD $700, R0
BR callbackasm1(SB)
MOVD $701, R0
BR callbackasm1(SB)
MOVD $702, R0
BR callbackasm1(SB)
MOVD $703, R0
BR callbackasm1(SB)
MOVD $704, R0
BR callbackasm1(SB)
MOVD $705, R0
BR callbackasm1(SB)
MOVD $706, R0
BR callbackasm1(SB)
MOVD $707, R0
BR callbackasm1(SB)
MOVD $708, R0
BR callbackasm1(SB)
MOVD $709, R0
BR callbackasm1(SB)
MOVD $710, R0
BR callbackasm1(SB)
MOVD $711, R0
BR callbackasm1(SB)
MOVD $712, R0
BR callbackasm1(SB)
MOVD $713, R0
BR callbackasm1(SB)
MOVD $714, R0
BR callbackasm1(SB)
MOVD $715, R0
BR callbackasm1(SB)
MOVD $716, R0
BR callbackasm1(SB)
MOVD $717, R0
BR callbackasm1(SB)
MOVD $718, R0
BR callbackasm1(SB)
MOVD $719, R0
BR callbackasm1(SB)
MOVD $720, R0
BR callbackasm1(SB)
MOVD $721, R0
BR callbackasm1(SB)
MOVD $722, R0
BR callbackasm1(SB)
MOVD $723, R0
BR callbackasm1(SB)
MOVD $724, R0
BR callbackasm1(SB)
MOVD $725, R0
BR callbackasm1(SB)
MOVD $726, R0
BR callbackasm1(SB)
MOVD $727, R0
BR callbackasm1(SB)
MOVD $728, R0
BR callbackasm1(SB)
MOVD $729, R0
BR callbackasm1(SB)
MOVD $730, R0
BR callbackasm1(SB)
MOVD $731, R0
BR callbackasm1(SB)
MOVD $732, R0
BR callbackasm1(SB)
MOVD $733, R0
BR callbackasm1(SB)
MOVD $734, R0
BR callbackasm1(SB)
MOVD $735, R0
BR callbackasm1(SB)
MOVD $736, R0
BR callbackasm1(SB)
MOVD $737, R0
BR callbackasm1(SB)
MOVD $738, R0
BR callbackasm1(SB)
MOVD $739, R0
BR callbackasm1(SB)
MOVD $740, R0
BR callbackasm1(SB)
MOVD $741, R0
BR callbackasm1(SB)
MOVD $742, R0
BR callbackasm1(SB)
MOVD $743, R0
BR callbackasm1(SB)
MOVD $744, R0
BR callbackasm1(SB)
MOVD $745, R0
BR callbackasm1(SB)
MOVD $746, R0
BR callbackasm1(SB)
MOVD $747, R0
BR callbackasm1(SB)
MOVD $748, R0
BR callbackasm1(SB)
MOVD $749, R0
BR callbackasm1(SB)
MOVD $750, R0
BR callbackasm1(SB)
MOVD $751, R0
BR callbackasm1(SB)
MOVD $752, R0
BR callbackasm1(SB)
MOVD $753, R0
BR callbackasm1(SB)
MOVD $754, R0
BR callbackasm1(SB)
MOVD $755, R0
BR callbackasm1(SB)
MOVD $756, R0
BR callbackasm1(SB)
MOVD $757, R0
BR callbackasm1(SB)
MOVD $758, R0
BR callbackasm1(SB)
MOVD $759, R0
BR callbackasm1(SB)
MOVD $760, R0
BR callbackasm1(SB)
MOVD $761, R0
BR callbackasm1(SB)
MOVD $762, R0
BR callbackasm1(SB)
MOVD $763, R0
BR callbackasm1(SB)
MOVD $764, R0
BR callbackasm1(SB)
MOVD $765, R0
BR callbackasm1(SB)
MOVD $766, R0
BR callbackasm1(SB)
MOVD $767, R0
BR callbackasm1(SB)
MOVD $768, R0
BR callbackasm1(SB)
MOVD $769, R0
BR callbackasm1(SB)
MOVD $770, R0
BR callbackasm1(SB)
MOVD $771, R0
BR callbackasm1(SB)
MOVD $772, R0
BR callbackasm1(SB)
MOVD $773, R0
BR callbackasm1(SB)
MOVD $774, R0
BR callbackasm1(SB)
MOVD $775, R0
BR callbackasm1(SB)
MOVD $776, R0
BR callbackasm1(SB)
MOVD $777, R0
BR callbackasm1(SB)
MOVD $778, R0
BR callbackasm1(SB)
MOVD $779, R0
BR callbackasm1(SB)
MOVD $780, R0
BR callbackasm1(SB)
MOVD $781, R0
BR callbackasm1(SB)
MOVD $782, R0
BR callbackasm1(SB)
MOVD $783, R0
BR callbackasm1(SB)
MOVD $784, R0
BR callbackasm1(SB)
MOVD $785, R0
BR callbackasm1(SB)
MOVD $786, R0
BR callbackasm1(SB)
MOVD $787, R0
BR callbackasm1(SB)
MOVD $788, R0
BR callbackasm1(SB)
MOVD $789, R0
BR callbackasm1(SB)
MOVD $790, R0
BR callbackasm1(SB)
MOVD $791, R0
BR callbackasm1(SB)
MOVD $792, R0
BR callbackasm1(SB)
MOVD $793, R0
BR callbackasm1(SB)
MOVD $794, R0
BR callbackasm1(SB)
MOVD $795, R0
BR callbackasm1(SB)
MOVD $796, R0
BR callbackasm1(SB)
MOVD $797, R0
BR callbackasm1(SB)
MOVD $798, R0
BR callbackasm1(SB)
MOVD $799, R0
BR callbackasm1(SB)
MOVD $800, R0
BR callbackasm1(SB)
MOVD $801, R0
BR callbackasm1(SB)
MOVD $802, R0
BR callbackasm1(SB)
MOVD $803, R0
BR callbackasm1(SB)
MOVD $804, R0
BR callbackasm1(SB)
MOVD $805, R0
BR callbackasm1(SB)
MOVD $806, R0
BR callbackasm1(SB)
MOVD $807, R0
BR callbackasm1(SB)
MOVD $808, R0
BR callbackasm1(SB)
MOVD $809, R0
BR callbackasm1(SB)
MOVD $810, R0
BR callbackasm1(SB)
MOVD $811, R0
BR callbackasm1(SB)
MOVD $812, R0
BR callbackasm1(SB)
MOVD $813, R0
BR callbackasm1(SB)
MOVD $814, R0
BR callbackasm1(SB)
MOVD $815, R0
BR callbackasm1(SB)
MOVD $816, R0
BR callbackasm1(SB)
MOVD $817, R0
BR callbackasm1(SB)
MOVD $818, R0
BR callbackasm1(SB)
MOVD $819, R0
BR callbackasm1(SB)
MOVD $820, R0
BR callbackasm1(SB)
MOVD $821, R0
BR callbackasm1(SB)
MOVD $822, R0
BR callbackasm1(SB)
MOVD $823, R0
BR callbackasm1(SB)
MOVD $824, R0
BR callbackasm1(SB)
MOVD $825, R0
BR callbackasm1(SB)
MOVD $826, R0
BR callbackasm1(SB)
MOVD $827, R0
BR callbackasm1(SB)
MOVD $828, R0
BR callbackasm1(SB)
MOVD $829, R0
BR callbackasm1(SB)
MOVD $830, R0
BR callbackasm1(SB)
MOVD $831, R0
BR callbackasm1(SB)
MOVD $832, R0
BR callbackasm1(SB)
MOVD $833, R0
BR callbackasm1(SB)
MOVD $834, R0
BR callbackasm1(SB)
MOVD $835, R0
BR callbackasm1(SB)
MOVD $836, R0
BR callbackasm1(SB)
MOVD $837, R0
BR callbackasm1(SB)
MOVD $838, R0
BR callbackasm1(SB)
MOVD $839, R0
BR callbackasm1(SB)
MOVD $840, R0
BR callbackasm1(SB)
MOVD $841, R0
BR callbackasm1(SB)
MOVD $842, R0
BR callbackasm1(SB)
MOVD $843, R0
BR callbackasm1(SB)
MOVD $844, R0
BR callbackasm1(SB)
MOVD $845, R0
BR callbackasm1(SB)
MOVD $846, R0
BR callbackasm1(SB)
MOVD $847, R0
BR callbackasm1(SB)
MOVD $848, R0
BR callbackasm1(SB)
MOVD $849, R0
BR callbackasm1(SB)
MOVD $850, R0
BR callbackasm1(SB)
MOVD $851, R0
BR callbackasm1(SB)
MOVD $852, R0
BR callbackasm1(SB)
MOVD $853, R0
BR callbackasm1(SB)
MOVD $854, R0
BR callbackasm1(SB)
MOVD $855, R0
BR callbackasm1(SB)
MOVD $856, R0
BR callbackasm1(SB)
MOVD $857, R0
BR callbackasm1(SB)
MOVD $858, R0
BR callbackasm1(SB)
MOVD $859, R0
BR callbackasm1(SB)
MOVD $860, R0
BR callbackasm1(SB)
MOVD $861, R0
BR callbackasm1(SB)
MOVD $862, R0
BR callbackasm1(SB)
MOVD $863, R0
BR callbackasm1(SB)
MOVD $864, R0
BR callbackasm1(SB)
MOVD $865, R0
BR callbackasm1(SB)
MOVD $866, R0
BR callbackasm1(SB)
MOVD $867, R0
BR callbackasm1(SB)
MOVD $868, R0
BR callbackasm1(SB)
MOVD $869, R0
BR callbackasm1(SB)
MOVD $870, R0
BR callbackasm1(SB)
MOVD $871, R0
BR callbackasm1(SB)
MOVD $872, R0
BR callbackasm1(SB)
MOVD $873, R0
BR callbackasm1(SB)
MOVD $874, R0
BR callbackasm1(SB)
MOVD $875, R0
BR callbackasm1(SB)
MOVD $876, R0
BR callbackasm1(SB)
MOVD $877, R0
BR callbackasm1(SB)
MOVD $878, R0
BR callbackasm1(SB)
MOVD $879, R0
BR callbackasm1(SB)
MOVD $880, R0
BR callbackasm1(SB)
MOVD $881, R0
BR callbackasm1(SB)
MOVD $882, R0
BR callbackasm1(SB)
MOVD $883, R0
BR callbackasm1(SB)
MOVD $884, R0
BR callbackasm1(SB)
MOVD $885, R0
BR callbackasm1(SB)
MOVD $886, R0
BR callbackasm1(SB)
MOVD $887, R0
BR callbackasm1(SB)
MOVD $888, R0
BR callbackasm1(SB)
MOVD $889, R0
BR callbackasm1(SB)
MOVD $890, R0
BR callbackasm1(SB)
MOVD $891, R0
BR callbackasm1(SB)
MOVD $892, R0
BR callbackasm1(SB)
MOVD $893, R0
BR callbackasm1(SB)
MOVD $894, R0
BR callbackasm1(SB)
MOVD $895, R0
BR callbackasm1(SB)
MOVD $896, R0
BR callbackasm1(SB)
MOVD $897, R0
BR callbackasm1(SB)
MOVD $898, R0
BR callbackasm1(SB)
MOVD $899, R0
BR callbackasm1(SB)
MOVD $900, R0
BR callbackasm1(SB)
MOVD $901, R0
BR callbackasm1(SB)
MOVD $902, R0
BR callbackasm1(SB)
MOVD $903, R0
BR callbackasm1(SB)
MOVD $904, R0
BR callbackasm1(SB)
MOVD $905, R0
BR callbackasm1(SB)
MOVD $906, R0
BR callbackasm1(SB)
MOVD $907, R0
BR callbackasm1(SB)
MOVD $908, R0
BR callbackasm1(SB)
MOVD $909, R0
BR callbackasm1(SB)
MOVD $910, R0
BR callbackasm1(SB)
MOVD $911, R0
BR callbackasm1(SB)
MOVD $912, R0
BR callbackasm1(SB)
MOVD $913, R0
BR callbackasm1(SB)
MOVD $914, R0
BR callbackasm1(SB)
MOVD $915, R0
BR callbackasm1(SB)
MOVD $916, R0
BR callbackasm1(SB)
MOVD $917, R0
BR callbackasm1(SB)
MOVD $918, R0
BR callbackasm1(SB)
MOVD $919, R0
BR callbackasm1(SB)
MOVD $920, R0
BR callbackasm1(SB)
MOVD $921, R0
BR callbackasm1(SB)
MOVD $922, R0
BR callbackasm1(SB)
MOVD $923, R0
BR callbackasm1(SB)
MOVD $924, R0
BR callbackasm1(SB)
MOVD $925, R0
BR callbackasm1(SB)
MOVD $926, R0
BR callbackasm1(SB)
MOVD $927, R0
BR callbackasm1(SB)
MOVD $928, R0
BR callbackasm1(SB)
MOVD $929, R0
BR callbackasm1(SB)
MOVD $930, R0
BR callbackasm1(SB)
MOVD $931, R0
BR callbackasm1(SB)
MOVD $932, R0
BR callbackasm1(SB)
MOVD $933, R0
BR callbackasm1(SB)
MOVD $934, R0
BR callbackasm1(SB)
MOVD $935, R0
BR callbackasm1(SB)
MOVD $936, R0
BR callbackasm1(SB)
MOVD $937, R0
BR callbackasm1(SB)
MOVD $938, R0
BR callbackasm1(SB)
MOVD $939, R0
BR callbackasm1(SB)
MOVD $940, R0
BR callbackasm1(SB)
MOVD $941, R0
BR callbackasm1(SB)
MOVD $942, R0
BR callbackasm1(SB)
MOVD $943, R0
BR callbackasm1(SB)
MOVD $944, R0
BR callbackasm1(SB)
MOVD $945, R0
BR callbackasm1(SB)
MOVD $946, R0
BR callbackasm1(SB)
MOVD $947, R0
BR callbackasm1(SB)
MOVD $948, R0
BR callbackasm1(SB)
MOVD $949, R0
BR callbackasm1(SB)
MOVD $950, R0
BR callbackasm1(SB)
MOVD $951, R0
BR callbackasm1(SB)
MOVD $952, R0
BR callbackasm1(SB)
MOVD $953, R0
BR callbackasm1(SB)
MOVD $954, R0
BR callbackasm1(SB)
MOVD $955, R0
BR callbackasm1(SB)
MOVD $956, R0
BR callbackasm1(SB)
MOVD $957, R0
BR callbackasm1(SB)
MOVD $958, R0
BR callbackasm1(SB)
MOVD $959, R0
BR callbackasm1(SB)
MOVD $960, R0
BR callbackasm1(SB)
MOVD $961, R0
BR callbackasm1(SB)
MOVD $962, R0
BR callbackasm1(SB)
MOVD $963, R0
BR callbackasm1(SB)
MOVD $964, R0
BR callbackasm1(SB)
MOVD $965, R0
BR callbackasm1(SB)
MOVD $966, R0
BR callbackasm1(SB)
MOVD $967, R0
BR callbackasm1(SB)
MOVD $968, R0
BR callbackasm1(SB)
MOVD $969, R0
BR callbackasm1(SB)
MOVD $970, R0
BR callbackasm1(SB)
MOVD $971, R0
BR callbackasm1(SB)
MOVD $972, R0
BR callbackasm1(SB)
MOVD $973, R0
BR callbackasm1(SB)
MOVD $974, R0
BR callbackasm1(SB)
MOVD $975, R0
BR callbackasm1(SB)
MOVD $976, R0
BR callbackasm1(SB)
MOVD $977, R0
BR callbackasm1(SB)
MOVD $978, R0
BR callbackasm1(SB)
MOVD $979, R0
BR callbackasm1(SB)
MOVD $980, R0
BR callbackasm1(SB)
MOVD $981, R0
BR callbackasm1(SB)
MOVD $982, R0
BR callbackasm1(SB)
MOVD $983, R0
BR callbackasm1(SB)
MOVD $984, R0
BR callbackasm1(SB)
MOVD $985, R0
BR callbackasm1(SB)
MOVD $986, R0
BR callbackasm1(SB)
MOVD $987, R0
BR callbackasm1(SB)
MOVD $988, R0
BR callbackasm1(SB)
MOVD $989, R0
BR callbackasm1(SB)
MOVD $990, R0
BR callbackasm1(SB)
MOVD $991, R0
BR callbackasm1(SB)
MOVD $992, R0
BR callbackasm1(SB)
MOVD $993, R0
BR callbackasm1(SB)
MOVD $994, R0
BR callbackasm1(SB)
MOVD $995, R0
BR callbackasm1(SB)
MOVD $996, R0
BR callbackasm1(SB)
MOVD $997, R0
BR callbackasm1(SB)
MOVD $998, R0
BR callbackasm1(SB)
MOVD $999, R0
BR callbackasm1(SB)
MOVD $1000, R0
BR callbackasm1(SB)
MOVD $1001, R0
BR callbackasm1(SB)
MOVD $1002, R0
BR callbackasm1(SB)
MOVD $1003, R0
BR callbackasm1(SB)
MOVD $1004, R0
BR callbackasm1(SB)
MOVD $1005, R0
BR callbackasm1(SB)
MOVD $1006, R0
BR callbackasm1(SB)
MOVD $1007, R0
BR callbackasm1(SB)
MOVD $1008, R0
BR callbackasm1(SB)
MOVD $1009, R0
BR callbackasm1(SB)
MOVD $1010, R0
BR callbackasm1(SB)
MOVD $1011, R0
BR callbackasm1(SB)
MOVD $1012, R0
BR callbackasm1(SB)
MOVD $1013, R0
BR callbackasm1(SB)
MOVD $1014, R0
BR callbackasm1(SB)
MOVD $1015, R0
BR callbackasm1(SB)
MOVD $1016, R0
BR callbackasm1(SB)
MOVD $1017, R0
BR callbackasm1(SB)
MOVD $1018, R0
BR callbackasm1(SB)
MOVD $1019, R0
BR callbackasm1(SB)
MOVD $1020, R0
BR callbackasm1(SB)
MOVD $1021, R0
BR callbackasm1(SB)
MOVD $1022, R0
BR callbackasm1(SB)
MOVD $1023, R0
BR callbackasm1(SB)
MOVD $1024, R0
BR callbackasm1(SB)
MOVD $1025, R0
BR callbackasm1(SB)
MOVD $1026, R0
BR callbackasm1(SB)
MOVD $1027, R0
BR callbackasm1(SB)
MOVD $1028, R0
BR callbackasm1(SB)
MOVD $1029, R0
BR callbackasm1(SB)
MOVD $1030, R0
BR callbackasm1(SB)
MOVD $1031, R0
BR callbackasm1(SB)
MOVD $1032, R0
BR callbackasm1(SB)
MOVD $1033, R0
BR callbackasm1(SB)
MOVD $1034, R0
BR callbackasm1(SB)
MOVD $1035, R0
BR callbackasm1(SB)
MOVD $1036, R0
BR callbackasm1(SB)
MOVD $1037, R0
BR callbackasm1(SB)
MOVD $1038, R0
BR callbackasm1(SB)
MOVD $1039, R0
BR callbackasm1(SB)
MOVD $1040, R0
BR callbackasm1(SB)
MOVD $1041, R0
BR callbackasm1(SB)
MOVD $1042, R0
BR callbackasm1(SB)
MOVD $1043, R0
BR callbackasm1(SB)
MOVD $1044, R0
BR callbackasm1(SB)
MOVD $1045, R0
BR callbackasm1(SB)
MOVD $1046, R0
BR callbackasm1(SB)
MOVD $1047, R0
BR callbackasm1(SB)
MOVD $1048, R0
BR callbackasm1(SB)
MOVD $1049, R0
BR callbackasm1(SB)
MOVD $1050, R0
BR callbackasm1(SB)
MOVD $1051, R0
BR callbackasm1(SB)
MOVD $1052, R0
BR callbackasm1(SB)
MOVD $1053, R0
BR callbackasm1(SB)
MOVD $1054, R0
BR callbackasm1(SB)
MOVD $1055, R0
BR callbackasm1(SB)
MOVD $1056, R0
BR callbackasm1(SB)
MOVD $1057, R0
BR callbackasm1(SB)
MOVD $1058, R0
BR callbackasm1(SB)
MOVD $1059, R0
BR callbackasm1(SB)
MOVD $1060, R0
BR callbackasm1(SB)
MOVD $1061, R0
BR callbackasm1(SB)
MOVD $1062, R0
BR callbackasm1(SB)
MOVD $1063, R0
BR callbackasm1(SB)
MOVD $1064, R0
BR callbackasm1(SB)
MOVD $1065, R0
BR callbackasm1(SB)
MOVD $1066, R0
BR callbackasm1(SB)
MOVD $1067, R0
BR callbackasm1(SB)
MOVD $1068, R0
BR callbackasm1(SB)
MOVD $1069, R0
BR callbackasm1(SB)
MOVD $1070, R0
BR callbackasm1(SB)
MOVD $1071, R0
BR callbackasm1(SB)
MOVD $1072, R0
BR callbackasm1(SB)
MOVD $1073, R0
BR callbackasm1(SB)
MOVD $1074, R0
BR callbackasm1(SB)
MOVD $1075, R0
BR callbackasm1(SB)
MOVD $1076, R0
BR callbackasm1(SB)
MOVD $1077, R0
BR callbackasm1(SB)
MOVD $1078, R0
BR callbackasm1(SB)
MOVD $1079, R0
BR callbackasm1(SB)
MOVD $1080, R0
BR callbackasm1(SB)
MOVD $1081, R0
BR callbackasm1(SB)
MOVD $1082, R0
BR callbackasm1(SB)
MOVD $1083, R0
BR callbackasm1(SB)
MOVD $1084, R0
BR callbackasm1(SB)
MOVD $1085, R0
BR callbackasm1(SB)
MOVD $1086, R0
BR callbackasm1(SB)
MOVD $1087, R0
BR callbackasm1(SB)
MOVD $1088, R0
BR callbackasm1(SB)
MOVD $1089, R0
BR callbackasm1(SB)
MOVD $1090, R0
BR callbackasm1(SB)
MOVD $1091, R0
BR callbackasm1(SB)
MOVD $1092, R0
BR callbackasm1(SB)
MOVD $1093, R0
BR callbackasm1(SB)
MOVD $1094, R0
BR callbackasm1(SB)
MOVD $1095, R0
BR callbackasm1(SB)
MOVD $1096, R0
BR callbackasm1(SB)
MOVD $1097, R0
BR callbackasm1(SB)
MOVD $1098, R0
BR callbackasm1(SB)
MOVD $1099, R0
BR callbackasm1(SB)
MOVD $1100, R0
BR callbackasm1(SB)
MOVD $1101, R0
BR callbackasm1(SB)
MOVD $1102, R0
BR callbackasm1(SB)
MOVD $1103, R0
BR callbackasm1(SB)
MOVD $1104, R0
BR callbackasm1(SB)
MOVD $1105, R0
BR callbackasm1(SB)
MOVD $1106, R0
BR callbackasm1(SB)
MOVD $1107, R0
BR callbackasm1(SB)
MOVD $1108, R0
BR callbackasm1(SB)
MOVD $1109, R0
BR callbackasm1(SB)
MOVD $1110, R0
BR callbackasm1(SB)
MOVD $1111, R0
BR callbackasm1(SB)
MOVD $1112, R0
BR callbackasm1(SB)
MOVD $1113, R0
BR callbackasm1(SB)
MOVD $1114, R0
BR callbackasm1(SB)
MOVD $1115, R0
BR callbackasm1(SB)
MOVD $1116, R0
BR callbackasm1(SB)
MOVD $1117, R0
BR callbackasm1(SB)
MOVD $1118, R0
BR callbackasm1(SB)
MOVD $1119, R0
BR callbackasm1(SB)
MOVD $1120, R0
BR callbackasm1(SB)
MOVD $1121, R0
BR callbackasm1(SB)
MOVD $1122, R0
BR callbackasm1(SB)
MOVD $1123, R0
BR callbackasm1(SB)
MOVD $1124, R0
BR callbackasm1(SB)
MOVD $1125, R0
BR callbackasm1(SB)
MOVD $1126, R0
BR callbackasm1(SB)
MOVD $1127, R0
BR callbackasm1(SB)
MOVD $1128, R0
BR callbackasm1(SB)
MOVD $1129, R0
BR callbackasm1(SB)
MOVD $1130, R0
BR callbackasm1(SB)
MOVD $1131, R0
BR callbackasm1(SB)
MOVD $1132, R0
BR callbackasm1(SB)
MOVD $1133, R0
BR callbackasm1(SB)
MOVD $1134, R0
BR callbackasm1(SB)
MOVD $1135, R0
BR callbackasm1(SB)
MOVD $1136, R0
BR callbackasm1(SB)
MOVD $1137, R0
BR callbackasm1(SB)
MOVD $1138, R0
BR callbackasm1(SB)
MOVD $1139, R0
BR callbackasm1(SB)
MOVD $1140, R0
BR callbackasm1(SB)
MOVD $1141, R0
BR callbackasm1(SB)
MOVD $1142, R0
BR callbackasm1(SB)
MOVD $1143, R0
BR callbackasm1(SB)
MOVD $1144, R0
BR callbackasm1(SB)
MOVD $1145, R0
BR callbackasm1(SB)
MOVD $1146, R0
BR callbackasm1(SB)
MOVD $1147, R0
BR callbackasm1(SB)
MOVD $1148, R0
BR callbackasm1(SB)
MOVD $1149, R0
BR callbackasm1(SB)
MOVD $1150, R0
BR callbackasm1(SB)
MOVD $1151, R0
BR callbackasm1(SB)
MOVD $1152, R0
BR callbackasm1(SB)
MOVD $1153, R0
BR callbackasm1(SB)
MOVD $1154, R0
BR callbackasm1(SB)
MOVD $1155, R0
BR callbackasm1(SB)
MOVD $1156, R0
BR callbackasm1(SB)
MOVD $1157, R0
BR callbackasm1(SB)
MOVD $1158, R0
BR callbackasm1(SB)
MOVD $1159, R0
BR callbackasm1(SB)
MOVD $1160, R0
BR callbackasm1(SB)
MOVD $1161, R0
BR callbackasm1(SB)
MOVD $1162, R0
BR callbackasm1(SB)
MOVD $1163, R0
BR callbackasm1(SB)
MOVD $1164, R0
BR callbackasm1(SB)
MOVD $1165, R0
BR callbackasm1(SB)
MOVD $1166, R0
BR callbackasm1(SB)
MOVD $1167, R0
BR callbackasm1(SB)
MOVD $1168, R0
BR callbackasm1(SB)
MOVD $1169, R0
BR callbackasm1(SB)
MOVD $1170, R0
BR callbackasm1(SB)
MOVD $1171, R0
BR callbackasm1(SB)
MOVD $1172, R0
BR callbackasm1(SB)
MOVD $1173, R0
BR callbackasm1(SB)
MOVD $1174, R0
BR callbackasm1(SB)
MOVD $1175, R0
BR callbackasm1(SB)
MOVD $1176, R0
BR callbackasm1(SB)
MOVD $1177, R0
BR callbackasm1(SB)
MOVD $1178, R0
BR callbackasm1(SB)
MOVD $1179, R0
BR callbackasm1(SB)
MOVD $1180, R0
BR callbackasm1(SB)
MOVD $1181, R0
BR callbackasm1(SB)
MOVD $1182, R0
BR callbackasm1(SB)
MOVD $1183, R0
BR callbackasm1(SB)
MOVD $1184, R0
BR callbackasm1(SB)
MOVD $1185, R0
BR callbackasm1(SB)
MOVD $1186, R0
BR callbackasm1(SB)
MOVD $1187, R0
BR callbackasm1(SB)
MOVD $1188, R0
BR callbackasm1(SB)
MOVD $1189, R0
BR callbackasm1(SB)
MOVD $1190, R0
BR callbackasm1(SB)
MOVD $1191, R0
BR callbackasm1(SB)
MOVD $1192, R0
BR callbackasm1(SB)
MOVD $1193, R0
BR callbackasm1(SB)
MOVD $1194, R0
BR callbackasm1(SB)
MOVD $1195, R0
BR callbackasm1(SB)
MOVD $1196, R0
BR callbackasm1(SB)
MOVD $1197, R0
BR callbackasm1(SB)
MOVD $1198, R0
BR callbackasm1(SB)
MOVD $1199, R0
BR callbackasm1(SB)
MOVD $1200, R0
BR callbackasm1(SB)
MOVD $1201, R0
BR callbackasm1(SB)
MOVD $1202, R0
BR callbackasm1(SB)
MOVD $1203, R0
BR callbackasm1(SB)
MOVD $1204, R0
BR callbackasm1(SB)
MOVD $1205, R0
BR callbackasm1(SB)
MOVD $1206, R0
BR callbackasm1(SB)
MOVD $1207, R0
BR callbackasm1(SB)
MOVD $1208, R0
BR callbackasm1(SB)
MOVD $1209, R0
BR callbackasm1(SB)
MOVD $1210, R0
BR callbackasm1(SB)
MOVD $1211, R0
BR callbackasm1(SB)
MOVD $1212, R0
BR callbackasm1(SB)
MOVD $1213, R0
BR callbackasm1(SB)
MOVD $1214, R0
BR callbackasm1(SB)
MOVD $1215, R0
BR callbackasm1(SB)
MOVD $1216, R0
BR callbackasm1(SB)
MOVD $1217, R0
BR callbackasm1(SB)
MOVD $1218, R0
BR callbackasm1(SB)
MOVD $1219, R0
BR callbackasm1(SB)
MOVD $1220, R0
BR callbackasm1(SB)
MOVD $1221, R0
BR callbackasm1(SB)
MOVD $1222, R0
BR callbackasm1(SB)
MOVD $1223, R0
BR callbackasm1(SB)
MOVD $1224, R0
BR callbackasm1(SB)
MOVD $1225, R0
BR callbackasm1(SB)
MOVD $1226, R0
BR callbackasm1(SB)
MOVD $1227, R0
BR callbackasm1(SB)
MOVD $1228, R0
BR callbackasm1(SB)
MOVD $1229, R0
BR callbackasm1(SB)
MOVD $1230, R0
BR callbackasm1(SB)
MOVD $1231, R0
BR callbackasm1(SB)
MOVD $1232, R0
BR callbackasm1(SB)
MOVD $1233, R0
BR callbackasm1(SB)
MOVD $1234, R0
BR callbackasm1(SB)
MOVD $1235, R0
BR callbackasm1(SB)
MOVD $1236, R0
BR callbackasm1(SB)
MOVD $1237, R0
BR callbackasm1(SB)
MOVD $1238, R0
BR callbackasm1(SB)
MOVD $1239, R0
BR callbackasm1(SB)
MOVD $1240, R0
BR callbackasm1(SB)
MOVD $1241, R0
BR callbackasm1(SB)
MOVD $1242, R0
BR callbackasm1(SB)
MOVD $1243, R0
BR callbackasm1(SB)
MOVD $1244, R0
BR callbackasm1(SB)
MOVD $1245, R0
BR callbackasm1(SB)
MOVD $1246, R0
BR callbackasm1(SB)
MOVD $1247, R0
BR callbackasm1(SB)
MOVD $1248, R0
BR callbackasm1(SB)
MOVD $1249, R0
BR callbackasm1(SB)
MOVD $1250, R0
BR callbackasm1(SB)
MOVD $1251, R0
BR callbackasm1(SB)
MOVD $1252, R0
BR callbackasm1(SB)
MOVD $1253, R0
BR callbackasm1(SB)
MOVD $1254, R0
BR callbackasm1(SB)
MOVD $1255, R0
BR callbackasm1(SB)
MOVD $1256, R0
BR callbackasm1(SB)
MOVD $1257, R0
BR callbackasm1(SB)
MOVD $1258, R0
BR callbackasm1(SB)
MOVD $1259, R0
BR callbackasm1(SB)
MOVD $1260, R0
BR callbackasm1(SB)
MOVD $1261, R0
BR callbackasm1(SB)
MOVD $1262, R0
BR callbackasm1(SB)
MOVD $1263, R0
BR callbackasm1(SB)
MOVD $1264, R0
BR callbackasm1(SB)
MOVD $1265, R0
BR callbackasm1(SB)
MOVD $1266, R0
BR callbackasm1(SB)
MOVD $1267, R0
BR callbackasm1(SB)
MOVD $1268, R0
BR callbackasm1(SB)
MOVD $1269, R0
BR callbackasm1(SB)
MOVD $1270, R0
BR callbackasm1(SB)
MOVD $1271, R0
BR callbackasm1(SB)
MOVD $1272, R0
BR callbackasm1(SB)
MOVD $1273, R0
BR callbackasm1(SB)
MOVD $1274, R0
BR callbackasm1(SB)
MOVD $1275, R0
BR callbackasm1(SB)
MOVD $1276, R0
BR callbackasm1(SB)
MOVD $1277, R0
BR callbackasm1(SB)
MOVD $1278, R0
BR callbackasm1(SB)
MOVD $1279, R0
BR callbackasm1(SB)
MOVD $1280, R0
BR callbackasm1(SB)
MOVD $1281, R0
BR callbackasm1(SB)
MOVD $1282, R0
BR callbackasm1(SB)
MOVD $1283, R0
BR callbackasm1(SB)
MOVD $1284, R0
BR callbackasm1(SB)
MOVD $1285, R0
BR callbackasm1(SB)
MOVD $1286, R0
BR callbackasm1(SB)
MOVD $1287, R0
BR callbackasm1(SB)
MOVD $1288, R0
BR callbackasm1(SB)
MOVD $1289, R0
BR callbackasm1(SB)
MOVD $1290, R0
BR callbackasm1(SB)
MOVD $1291, R0
BR callbackasm1(SB)
MOVD $1292, R0
BR callbackasm1(SB)
MOVD $1293, R0
BR callbackasm1(SB)
MOVD $1294, R0
BR callbackasm1(SB)
MOVD $1295, R0
BR callbackasm1(SB)
MOVD $1296, R0
BR callbackasm1(SB)
MOVD $1297, R0
BR callbackasm1(SB)
MOVD $1298, R0
BR callbackasm1(SB)
MOVD $1299, R0
BR callbackasm1(SB)
MOVD $1300, R0
BR callbackasm1(SB)
MOVD $1301, R0
BR callbackasm1(SB)
MOVD $1302, R0
BR callbackasm1(SB)
MOVD $1303, R0
BR callbackasm1(SB)
MOVD $1304, R0
BR callbackasm1(SB)
MOVD $1305, R0
BR callbackasm1(SB)
MOVD $1306, R0
BR callbackasm1(SB)
MOVD $1307, R0
BR callbackasm1(SB)
MOVD $1308, R0
BR callbackasm1(SB)
MOVD $1309, R0
BR callbackasm1(SB)
MOVD $1310, R0
BR callbackasm1(SB)
MOVD $1311, R0
BR callbackasm1(SB)
MOVD $1312, R0
BR callbackasm1(SB)
MOVD $1313, R0
BR callbackasm1(SB)
MOVD $1314, R0
BR callbackasm1(SB)
MOVD $1315, R0
BR callbackasm1(SB)
MOVD $1316, R0
BR callbackasm1(SB)
MOVD $1317, R0
BR callbackasm1(SB)
MOVD $1318, R0
BR callbackasm1(SB)
MOVD $1319, R0
BR callbackasm1(SB)
MOVD $1320, R0
BR callbackasm1(SB)
MOVD $1321, R0
BR callbackasm1(SB)
MOVD $1322, R0
BR callbackasm1(SB)
MOVD $1323, R0
BR callbackasm1(SB)
MOVD $1324, R0
BR callbackasm1(SB)
MOVD $1325, R0
BR callbackasm1(SB)
MOVD $1326, R0
BR callbackasm1(SB)
MOVD $1327, R0
BR callbackasm1(SB)
MOVD $1328, R0
BR callbackasm1(SB)
MOVD $1329, R0
BR callbackasm1(SB)
MOVD $1330, R0
BR callbackasm1(SB)
MOVD $1331, R0
BR callbackasm1(SB)
MOVD $1332, R0
BR callbackasm1(SB)
MOVD $1333, R0
BR callbackasm1(SB)
MOVD $1334, R0
BR callbackasm1(SB)
MOVD $1335, R0
BR callbackasm1(SB)
MOVD $1336, R0
BR callbackasm1(SB)
MOVD $1337, R0
BR callbackasm1(SB)
MOVD $1338, R0
BR callbackasm1(SB)
MOVD $1339, R0
BR callbackasm1(SB)
MOVD $1340, R0
BR callbackasm1(SB)
MOVD $1341, R0
BR callbackasm1(SB)
MOVD $1342, R0
BR callbackasm1(SB)
MOVD $1343, R0
BR callbackasm1(SB)
MOVD $1344, R0
BR callbackasm1(SB)
MOVD $1345, R0
BR callbackasm1(SB)
MOVD $1346, R0
BR callbackasm1(SB)
MOVD $1347, R0
BR callbackasm1(SB)
MOVD $1348, R0
BR callbackasm1(SB)
MOVD $1349, R0
BR callbackasm1(SB)
MOVD $1350, R0
BR callbackasm1(SB)
MOVD $1351, R0
BR callbackasm1(SB)
MOVD $1352, R0
BR callbackasm1(SB)
MOVD $1353, R0
BR callbackasm1(SB)
MOVD $1354, R0
BR callbackasm1(SB)
MOVD $1355, R0
BR callbackasm1(SB)
MOVD $1356, R0
BR callbackasm1(SB)
MOVD $1357, R0
BR callbackasm1(SB)
MOVD $1358, R0
BR callbackasm1(SB)
MOVD $1359, R0
BR callbackasm1(SB)
MOVD $1360, R0
BR callbackasm1(SB)
MOVD $1361, R0
BR callbackasm1(SB)
MOVD $1362, R0
BR callbackasm1(SB)
MOVD $1363, R0
BR callbackasm1(SB)
MOVD $1364, R0
BR callbackasm1(SB)
MOVD $1365, R0
BR callbackasm1(SB)
MOVD $1366, R0
BR callbackasm1(SB)
MOVD $1367, R0
BR callbackasm1(SB)
MOVD $1368, R0
BR callbackasm1(SB)
MOVD $1369, R0
BR callbackasm1(SB)
MOVD $1370, R0
BR callbackasm1(SB)
MOVD $1371, R0
BR callbackasm1(SB)
MOVD $1372, R0
BR callbackasm1(SB)
MOVD $1373, R0
BR callbackasm1(SB)
MOVD $1374, R0
BR callbackasm1(SB)
MOVD $1375, R0
BR callbackasm1(SB)
MOVD $1376, R0
BR callbackasm1(SB)
MOVD $1377, R0
BR callbackasm1(SB)
MOVD $1378, R0
BR callbackasm1(SB)
MOVD $1379, R0
BR callbackasm1(SB)
MOVD $1380, R0
BR callbackasm1(SB)
MOVD $1381, R0
BR callbackasm1(SB)
MOVD $1382, R0
BR callbackasm1(SB)
MOVD $1383, R0
BR callbackasm1(SB)
MOVD $1384, R0
BR callbackasm1(SB)
MOVD $1385, R0
BR callbackasm1(SB)
MOVD $1386, R0
BR callbackasm1(SB)
MOVD $1387, R0
BR callbackasm1(SB)
MOVD $1388, R0
BR callbackasm1(SB)
MOVD $1389, R0
BR callbackasm1(SB)
MOVD $1390, R0
BR callbackasm1(SB)
MOVD $1391, R0
BR callbackasm1(SB)
MOVD $1392, R0
BR callbackasm1(SB)
MOVD $1393, R0
BR callbackasm1(SB)
MOVD $1394, R0
BR callbackasm1(SB)
MOVD $1395, R0
BR callbackasm1(SB)
MOVD $1396, R0
BR callbackasm1(SB)
MOVD $1397, R0
BR callbackasm1(SB)
MOVD $1398, R0
BR callbackasm1(SB)
MOVD $1399, R0
BR callbackasm1(SB)
MOVD $1400, R0
BR callbackasm1(SB)
MOVD $1401, R0
BR callbackasm1(SB)
MOVD $1402, R0
BR callbackasm1(SB)
MOVD $1403, R0
BR callbackasm1(SB)
MOVD $1404, R0
BR callbackasm1(SB)
MOVD $1405, R0
BR callbackasm1(SB)
MOVD $1406, R0
BR callbackasm1(SB)
MOVD $1407, R0
BR callbackasm1(SB)
MOVD $1408, R0
BR callbackasm1(SB)
MOVD $1409, R0
BR callbackasm1(SB)
MOVD $1410, R0
BR callbackasm1(SB)
MOVD $1411, R0
BR callbackasm1(SB)
MOVD $1412, R0
BR callbackasm1(SB)
MOVD $1413, R0
BR callbackasm1(SB)
MOVD $1414, R0
BR callbackasm1(SB)
MOVD $1415, R0
BR callbackasm1(SB)
MOVD $1416, R0
BR callbackasm1(SB)
MOVD $1417, R0
BR callbackasm1(SB)
MOVD $1418, R0
BR callbackasm1(SB)
MOVD $1419, R0
BR callbackasm1(SB)
MOVD $1420, R0
BR callbackasm1(SB)
MOVD $1421, R0
BR callbackasm1(SB)
MOVD $1422, R0
BR callbackasm1(SB)
MOVD $1423, R0
BR callbackasm1(SB)
MOVD $1424, R0
BR callbackasm1(SB)
MOVD $1425, R0
BR callbackasm1(SB)
MOVD $1426, R0
BR callbackasm1(SB)
MOVD $1427, R0
BR callbackasm1(SB)
MOVD $1428, R0
BR callbackasm1(SB)
MOVD $1429, R0
BR callbackasm1(SB)
MOVD $1430, R0
BR callbackasm1(SB)
MOVD $1431, R0
BR callbackasm1(SB)
MOVD $1432, R0
BR callbackasm1(SB)
MOVD $1433, R0
BR callbackasm1(SB)
MOVD $1434, R0
BR callbackasm1(SB)
MOVD $1435, R0
BR callbackasm1(SB)
MOVD $1436, R0
BR callbackasm1(SB)
MOVD $1437, R0
BR callbackasm1(SB)
MOVD $1438, R0
BR callbackasm1(SB)
MOVD $1439, R0
BR callbackasm1(SB)
MOVD $1440, R0
BR callbackasm1(SB)
MOVD $1441, R0
BR callbackasm1(SB)
MOVD $1442, R0
BR callbackasm1(SB)
MOVD $1443, R0
BR callbackasm1(SB)
MOVD $1444, R0
BR callbackasm1(SB)
MOVD $1445, R0
BR callbackasm1(SB)
MOVD $1446, R0
BR callbackasm1(SB)
MOVD $1447, R0
BR callbackasm1(SB)
MOVD $1448, R0
BR callbackasm1(SB)
MOVD $1449, R0
BR callbackasm1(SB)
MOVD $1450, R0
BR callbackasm1(SB)
MOVD $1451, R0
BR callbackasm1(SB)
MOVD $1452, R0
BR callbackasm1(SB)
MOVD $1453, R0
BR callbackasm1(SB)
MOVD $1454, R0
BR callbackasm1(SB)
MOVD $1455, R0
BR callbackasm1(SB)
MOVD $1456, R0
BR callbackasm1(SB)
MOVD $1457, R0
BR callbackasm1(SB)
MOVD $1458, R0
BR callbackasm1(SB)
MOVD $1459, R0
BR callbackasm1(SB)
MOVD $1460, R0
BR callbackasm1(SB)
MOVD $1461, R0
BR callbackasm1(SB)
MOVD $1462, R0
BR callbackasm1(SB)
MOVD $1463, R0
BR callbackasm1(SB)
MOVD $1464, R0
BR callbackasm1(SB)
MOVD $1465, R0
BR callbackasm1(SB)
MOVD $1466, R0
BR callbackasm1(SB)
MOVD $1467, R0
BR callbackasm1(SB)
MOVD $1468, R0
BR callbackasm1(SB)
MOVD $1469, R0
BR callbackasm1(SB)
MOVD $1470, R0
BR callbackasm1(SB)
MOVD $1471, R0
BR callbackasm1(SB)
MOVD $1472, R0
BR callbackasm1(SB)
MOVD $1473, R0
BR callbackasm1(SB)
MOVD $1474, R0
BR callbackasm1(SB)
MOVD $1475, R0
BR callbackasm1(SB)
MOVD $1476, R0
BR callbackasm1(SB)
MOVD $1477, R0
BR callbackasm1(SB)
MOVD $1478, R0
BR callbackasm1(SB)
MOVD $1479, R0
BR callbackasm1(SB)
MOVD $1480, R0
BR callbackasm1(SB)
MOVD $1481, R0
BR callbackasm1(SB)
MOVD $1482, R0
BR callbackasm1(SB)
MOVD $1483, R0
BR callbackasm1(SB)
MOVD $1484, R0
BR callbackasm1(SB)
MOVD $1485, R0
BR callbackasm1(SB)
MOVD $1486, R0
BR callbackasm1(SB)
MOVD $1487, R0
BR callbackasm1(SB)
MOVD $1488, R0
BR callbackasm1(SB)
MOVD $1489, R0
BR callbackasm1(SB)
MOVD $1490, R0
BR callbackasm1(SB)
MOVD $1491, R0
BR callbackasm1(SB)
MOVD $1492, R0
BR callbackasm1(SB)
MOVD $1493, R0
BR callbackasm1(SB)
MOVD $1494, R0
BR callbackasm1(SB)
MOVD $1495, R0
BR callbackasm1(SB)
MOVD $1496, R0
BR callbackasm1(SB)
MOVD $1497, R0
BR callbackasm1(SB)
MOVD $1498, R0
BR callbackasm1(SB)
MOVD $1499, R0
BR callbackasm1(SB)
MOVD $1500, R0
BR callbackasm1(SB)
MOVD $1501, R0
BR callbackasm1(SB)
MOVD $1502, R0
BR callbackasm1(SB)
MOVD $1503, R0
BR callbackasm1(SB)
MOVD $1504, R0
BR callbackasm1(SB)
MOVD $1505, R0
BR callbackasm1(SB)
MOVD $1506, R0
BR callbackasm1(SB)
MOVD $1507, R0
BR callbackasm1(SB)
MOVD $1508, R0
BR callbackasm1(SB)
MOVD $1509, R0
BR callbackasm1(SB)
MOVD $1510, R0
BR callbackasm1(SB)
MOVD $1511, R0
BR callbackasm1(SB)
MOVD $1512, R0
BR callbackasm1(SB)
MOVD $1513, R0
BR callbackasm1(SB)
MOVD $1514, R0
BR callbackasm1(SB)
MOVD $1515, R0
BR callbackasm1(SB)
MOVD $1516, R0
BR callbackasm1(SB)
MOVD $1517, R0
BR callbackasm1(SB)
MOVD $1518, R0
BR callbackasm1(SB)
MOVD $1519, R0
BR callbackasm1(SB)
MOVD $1520, R0
BR callbackasm1(SB)
MOVD $1521, R0
BR callbackasm1(SB)
MOVD $1522, R0
BR callbackasm1(SB)
MOVD $1523, R0
BR callbackasm1(SB)
MOVD $1524, R0
BR callbackasm1(SB)
MOVD $1525, R0
BR callbackasm1(SB)
MOVD $1526, R0
BR callbackasm1(SB)
MOVD $1527, R0
BR callbackasm1(SB)
MOVD $1528, R0
BR callbackasm1(SB)
MOVD $1529, R0
BR callbackasm1(SB)
MOVD $1530, R0
BR callbackasm1(SB)
MOVD $1531, R0
BR callbackasm1(SB)
MOVD $1532, R0
BR callbackasm1(SB)
MOVD $1533, R0
BR callbackasm1(SB)
MOVD $1534, R0
BR callbackasm1(SB)
MOVD $1535, R0
BR callbackasm1(SB)
MOVD $1536, R0
BR callbackasm1(SB)
MOVD $1537, R0
BR callbackasm1(SB)
MOVD $1538, R0
BR callbackasm1(SB)
MOVD $1539, R0
BR callbackasm1(SB)
MOVD $1540, R0
BR callbackasm1(SB)
MOVD $1541, R0
BR callbackasm1(SB)
MOVD $1542, R0
BR callbackasm1(SB)
MOVD $1543, R0
BR callbackasm1(SB)
MOVD $1544, R0
BR callbackasm1(SB)
MOVD $1545, R0
BR callbackasm1(SB)
MOVD $1546, R0
BR callbackasm1(SB)
MOVD $1547, R0
BR callbackasm1(SB)
MOVD $1548, R0
BR callbackasm1(SB)
MOVD $1549, R0
BR callbackasm1(SB)
MOVD $1550, R0
BR callbackasm1(SB)
MOVD $1551, R0
BR callbackasm1(SB)
MOVD $1552, R0
BR callbackasm1(SB)
MOVD $1553, R0
BR callbackasm1(SB)
MOVD $1554, R0
BR callbackasm1(SB)
MOVD $1555, R0
BR callbackasm1(SB)
MOVD $1556, R0
BR callbackasm1(SB)
MOVD $1557, R0
BR callbackasm1(SB)
MOVD $1558, R0
BR callbackasm1(SB)
MOVD $1559, R0
BR callbackasm1(SB)
MOVD $1560, R0
BR callbackasm1(SB)
MOVD $1561, R0
BR callbackasm1(SB)
MOVD $1562, R0
BR callbackasm1(SB)
MOVD $1563, R0
BR callbackasm1(SB)
MOVD $1564, R0
BR callbackasm1(SB)
MOVD $1565, R0
BR callbackasm1(SB)
MOVD $1566, R0
BR callbackasm1(SB)
MOVD $1567, R0
BR callbackasm1(SB)
MOVD $1568, R0
BR callbackasm1(SB)
MOVD $1569, R0
BR callbackasm1(SB)
MOVD $1570, R0
BR callbackasm1(SB)
MOVD $1571, R0
BR callbackasm1(SB)
MOVD $1572, R0
BR callbackasm1(SB)
MOVD $1573, R0
BR callbackasm1(SB)
MOVD $1574, R0
BR callbackasm1(SB)
MOVD $1575, R0
BR callbackasm1(SB)
MOVD $1576, R0
BR callbackasm1(SB)
MOVD $1577, R0
BR callbackasm1(SB)
MOVD $1578, R0
BR callbackasm1(SB)
MOVD $1579, R0
BR callbackasm1(SB)
MOVD $1580, R0
BR callbackasm1(SB)
MOVD $1581, R0
BR callbackasm1(SB)
MOVD $1582, R0
BR callbackasm1(SB)
MOVD $1583, R0
BR callbackasm1(SB)
MOVD $1584, R0
BR callbackasm1(SB)
MOVD $1585, R0
BR callbackasm1(SB)
MOVD $1586, R0
BR callbackasm1(SB)
MOVD $1587, R0
BR callbackasm1(SB)
MOVD $1588, R0
BR callbackasm1(SB)
MOVD $1589, R0
BR callbackasm1(SB)
MOVD $1590, R0
BR callbackasm1(SB)
MOVD $1591, R0
BR callbackasm1(SB)
MOVD $1592, R0
BR callbackasm1(SB)
MOVD $1593, R0
BR callbackasm1(SB)
MOVD $1594, R0
BR callbackasm1(SB)
MOVD $1595, R0
BR callbackasm1(SB)
MOVD $1596, R0
BR callbackasm1(SB)
MOVD $1597, R0
BR callbackasm1(SB)
MOVD $1598, R0
BR callbackasm1(SB)
MOVD $1599, R0
BR callbackasm1(SB)
MOVD $1600, R0
BR callbackasm1(SB)
MOVD $1601, R0
BR callbackasm1(SB)
MOVD $1602, R0
BR callbackasm1(SB)
MOVD $1603, R0
BR callbackasm1(SB)
MOVD $1604, R0
BR callbackasm1(SB)
MOVD $1605, R0
BR callbackasm1(SB)
MOVD $1606, R0
BR callbackasm1(SB)
MOVD $1607, R0
BR callbackasm1(SB)
MOVD $1608, R0
BR callbackasm1(SB)
MOVD $1609, R0
BR callbackasm1(SB)
MOVD $1610, R0
BR callbackasm1(SB)
MOVD $1611, R0
BR callbackasm1(SB)
MOVD $1612, R0
BR callbackasm1(SB)
MOVD $1613, R0
BR callbackasm1(SB)
MOVD $1614, R0
BR callbackasm1(SB)
MOVD $1615, R0
BR callbackasm1(SB)
MOVD $1616, R0
BR callbackasm1(SB)
MOVD $1617, R0
BR callbackasm1(SB)
MOVD $1618, R0
BR callbackasm1(SB)
MOVD $1619, R0
BR callbackasm1(SB)
MOVD $1620, R0
BR callbackasm1(SB)
MOVD $1621, R0
BR callbackasm1(SB)
MOVD $1622, R0
BR callbackasm1(SB)
MOVD $1623, R0
BR callbackasm1(SB)
MOVD $1624, R0
BR callbackasm1(SB)
MOVD $1625, R0
BR callbackasm1(SB)
MOVD $1626, R0
BR callbackasm1(SB)
MOVD $1627, R0
BR callbackasm1(SB)
MOVD $1628, R0
BR callbackasm1(SB)
MOVD $1629, R0
BR callbackasm1(SB)
MOVD $1630, R0
BR callbackasm1(SB)
MOVD $1631, R0
BR callbackasm1(SB)
MOVD $1632, R0
BR callbackasm1(SB)
MOVD $1633, R0
BR callbackasm1(SB)
MOVD $1634, R0
BR callbackasm1(SB)
MOVD $1635, R0
BR callbackasm1(SB)
MOVD $1636, R0
BR callbackasm1(SB)
MOVD $1637, R0
BR callbackasm1(SB)
MOVD $1638, R0
BR callbackasm1(SB)
MOVD $1639, R0
BR callbackasm1(SB)
MOVD $1640, R0
BR callbackasm1(SB)
MOVD $1641, R0
BR callbackasm1(SB)
MOVD $1642, R0
BR callbackasm1(SB)
MOVD $1643, R0
BR callbackasm1(SB)
MOVD $1644, R0
BR callbackasm1(SB)
MOVD $1645, R0
BR callbackasm1(SB)
MOVD $1646, R0
BR callbackasm1(SB)
MOVD $1647, R0
BR callbackasm1(SB)
MOVD $1648, R0
BR callbackasm1(SB)
MOVD $1649, R0
BR callbackasm1(SB)
MOVD $1650, R0
BR callbackasm1(SB)
MOVD $1651, R0
BR callbackasm1(SB)
MOVD $1652, R0
BR callbackasm1(SB)
MOVD $1653, R0
BR callbackasm1(SB)
MOVD $1654, R0
BR callbackasm1(SB)
MOVD $1655, R0
BR callbackasm1(SB)
MOVD $1656, R0
BR callbackasm1(SB)
MOVD $1657, R0
BR callbackasm1(SB)
MOVD $1658, R0
BR callbackasm1(SB)
MOVD $1659, R0
BR callbackasm1(SB)
MOVD $1660, R0
BR callbackasm1(SB)
MOVD $1661, R0
BR callbackasm1(SB)
MOVD $1662, R0
BR callbackasm1(SB)
MOVD $1663, R0
BR callbackasm1(SB)
MOVD $1664, R0
BR callbackasm1(SB)
MOVD $1665, R0
BR callbackasm1(SB)
MOVD $1666, R0
BR callbackasm1(SB)
MOVD $1667, R0
BR callbackasm1(SB)
MOVD $1668, R0
BR callbackasm1(SB)
MOVD $1669, R0
BR callbackasm1(SB)
MOVD $1670, R0
BR callbackasm1(SB)
MOVD $1671, R0
BR callbackasm1(SB)
MOVD $1672, R0
BR callbackasm1(SB)
MOVD $1673, R0
BR callbackasm1(SB)
MOVD $1674, R0
BR callbackasm1(SB)
MOVD $1675, R0
BR callbackasm1(SB)
MOVD $1676, R0
BR callbackasm1(SB)
MOVD $1677, R0
BR callbackasm1(SB)
MOVD $1678, R0
BR callbackasm1(SB)
MOVD $1679, R0
BR callbackasm1(SB)
MOVD $1680, R0
BR callbackasm1(SB)
MOVD $1681, R0
BR callbackasm1(SB)
MOVD $1682, R0
BR callbackasm1(SB)
MOVD $1683, R0
BR callbackasm1(SB)
MOVD $1684, R0
BR callbackasm1(SB)
MOVD $1685, R0
BR callbackasm1(SB)
MOVD $1686, R0
BR callbackasm1(SB)
MOVD $1687, R0
BR callbackasm1(SB)
MOVD $1688, R0
BR callbackasm1(SB)
MOVD $1689, R0
BR callbackasm1(SB)
MOVD $1690, R0
BR callbackasm1(SB)
MOVD $1691, R0
BR callbackasm1(SB)
MOVD $1692, R0
BR callbackasm1(SB)
MOVD $1693, R0
BR callbackasm1(SB)
MOVD $1694, R0
BR callbackasm1(SB)
MOVD $1695, R0
BR callbackasm1(SB)
MOVD $1696, R0
BR callbackasm1(SB)
MOVD $1697, R0
BR callbackasm1(SB)
MOVD $1698, R0
BR callbackasm1(SB)
MOVD $1699, R0
BR callbackasm1(SB)
MOVD $1700, R0
BR callbackasm1(SB)
MOVD $1701, R0
BR callbackasm1(SB)
MOVD $1702, R0
BR callbackasm1(SB)
MOVD $1703, R0
BR callbackasm1(SB)
MOVD $1704, R0
BR callbackasm1(SB)
MOVD $1705, R0
BR callbackasm1(SB)
MOVD $1706, R0
BR callbackasm1(SB)
MOVD $1707, R0
BR callbackasm1(SB)
MOVD $1708, R0
BR callbackasm1(SB)
MOVD $1709, R0
BR callbackasm1(SB)
MOVD $1710, R0
BR callbackasm1(SB)
MOVD $1711, R0
BR callbackasm1(SB)
MOVD $1712, R0
BR callbackasm1(SB)
MOVD $1713, R0
BR callbackasm1(SB)
MOVD $1714, R0
BR callbackasm1(SB)
MOVD $1715, R0
BR callbackasm1(SB)
MOVD $1716, R0
BR callbackasm1(SB)
MOVD $1717, R0
BR callbackasm1(SB)
MOVD $1718, R0
BR callbackasm1(SB)
MOVD $1719, R0
BR callbackasm1(SB)
MOVD $1720, R0
BR callbackasm1(SB)
MOVD $1721, R0
BR callbackasm1(SB)
MOVD $1722, R0
BR callbackasm1(SB)
MOVD $1723, R0
BR callbackasm1(SB)
MOVD $1724, R0
BR callbackasm1(SB)
MOVD $1725, R0
BR callbackasm1(SB)
MOVD $1726, R0
BR callbackasm1(SB)
MOVD $1727, R0
BR callbackasm1(SB)
MOVD $1728, R0
BR callbackasm1(SB)
MOVD $1729, R0
BR callbackasm1(SB)
MOVD $1730, R0
BR callbackasm1(SB)
MOVD $1731, R0
BR callbackasm1(SB)
MOVD $1732, R0
BR callbackasm1(SB)
MOVD $1733, R0
BR callbackasm1(SB)
MOVD $1734, R0
BR callbackasm1(SB)
MOVD $1735, R0
BR callbackasm1(SB)
MOVD $1736, R0
BR callbackasm1(SB)
MOVD $1737, R0
BR callbackasm1(SB)
MOVD $1738, R0
BR callbackasm1(SB)
MOVD $1739, R0
BR callbackasm1(SB)
MOVD $1740, R0
BR callbackasm1(SB)
MOVD $1741, R0
BR callbackasm1(SB)
MOVD $1742, R0
BR callbackasm1(SB)
MOVD $1743, R0
BR callbackasm1(SB)
MOVD $1744, R0
BR callbackasm1(SB)
MOVD $1745, R0
BR callbackasm1(SB)
MOVD $1746, R0
BR callbackasm1(SB)
MOVD $1747, R0
BR callbackasm1(SB)
MOVD $1748, R0
BR callbackasm1(SB)
MOVD $1749, R0
BR callbackasm1(SB)
MOVD $1750, R0
BR callbackasm1(SB)
MOVD $1751, R0
BR callbackasm1(SB)
MOVD $1752, R0
BR callbackasm1(SB)
MOVD $1753, R0
BR callbackasm1(SB)
MOVD $1754, R0
BR callbackasm1(SB)
MOVD $1755, R0
BR callbackasm1(SB)
MOVD $1756, R0
BR callbackasm1(SB)
MOVD $1757, R0
BR callbackasm1(SB)
MOVD $1758, R0
BR callbackasm1(SB)
MOVD $1759, R0
BR callbackasm1(SB)
MOVD $1760, R0
BR callbackasm1(SB)
MOVD $1761, R0
BR callbackasm1(SB)
MOVD $1762, R0
BR callbackasm1(SB)
MOVD $1763, R0
BR callbackasm1(SB)
MOVD $1764, R0
BR callbackasm1(SB)
MOVD $1765, R0
BR callbackasm1(SB)
MOVD $1766, R0
BR callbackasm1(SB)
MOVD $1767, R0
BR callbackasm1(SB)
MOVD $1768, R0
BR callbackasm1(SB)
MOVD $1769, R0
BR callbackasm1(SB)
MOVD $1770, R0
BR callbackasm1(SB)
MOVD $1771, R0
BR callbackasm1(SB)
MOVD $1772, R0
BR callbackasm1(SB)
MOVD $1773, R0
BR callbackasm1(SB)
MOVD $1774, R0
BR callbackasm1(SB)
MOVD $1775, R0
BR callbackasm1(SB)
MOVD $1776, R0
BR callbackasm1(SB)
MOVD $1777, R0
BR callbackasm1(SB)
MOVD $1778, R0
BR callbackasm1(SB)
MOVD $1779, R0
BR callbackasm1(SB)
MOVD $1780, R0
BR callbackasm1(SB)
MOVD $1781, R0
BR callbackasm1(SB)
MOVD $1782, R0
BR callbackasm1(SB)
MOVD $1783, R0
BR callbackasm1(SB)
MOVD $1784, R0
BR callbackasm1(SB)
MOVD $1785, R0
BR callbackasm1(SB)
MOVD $1786, R0
BR callbackasm1(SB)
MOVD $1787, R0
BR callbackasm1(SB)
MOVD $1788, R0
BR callbackasm1(SB)
MOVD $1789, R0
BR callbackasm1(SB)
MOVD $1790, R0
BR callbackasm1(SB)
MOVD $1791, R0
BR callbackasm1(SB)
MOVD $1792, R0
BR callbackasm1(SB)
MOVD $1793, R0
BR callbackasm1(SB)
MOVD $1794, R0
BR callbackasm1(SB)
MOVD $1795, R0
BR callbackasm1(SB)
MOVD $1796, R0
BR callbackasm1(SB)
MOVD $1797, R0
BR callbackasm1(SB)
MOVD $1798, R0
BR callbackasm1(SB)
MOVD $1799, R0
BR callbackasm1(SB)
MOVD $1800, R0
BR callbackasm1(SB)
MOVD $1801, R0
BR callbackasm1(SB)
MOVD $1802, R0
BR callbackasm1(SB)
MOVD $1803, R0
BR callbackasm1(SB)
MOVD $1804, R0
BR callbackasm1(SB)
MOVD $1805, R0
BR callbackasm1(SB)
MOVD $1806, R0
BR callbackasm1(SB)
MOVD $1807, R0
BR callbackasm1(SB)
MOVD $1808, R0
BR callbackasm1(SB)
MOVD $1809, R0
BR callbackasm1(SB)
MOVD $1810, R0
BR callbackasm1(SB)
MOVD $1811, R0
BR callbackasm1(SB)
MOVD $1812, R0
BR callbackasm1(SB)
MOVD $1813, R0
BR callbackasm1(SB)
MOVD $1814, R0
BR callbackasm1(SB)
MOVD $1815, R0
BR callbackasm1(SB)
MOVD $1816, R0
BR callbackasm1(SB)
MOVD $1817, R0
BR callbackasm1(SB)
MOVD $1818, R0
BR callbackasm1(SB)
MOVD $1819, R0
BR callbackasm1(SB)
MOVD $1820, R0
BR callbackasm1(SB)
MOVD $1821, R0
BR callbackasm1(SB)
MOVD $1822, R0
BR callbackasm1(SB)
MOVD $1823, R0
BR callbackasm1(SB)
MOVD $1824, R0
BR callbackasm1(SB)
MOVD $1825, R0
BR callbackasm1(SB)
MOVD $1826, R0
BR callbackasm1(SB)
MOVD $1827, R0
BR callbackasm1(SB)
MOVD $1828, R0
BR callbackasm1(SB)
MOVD $1829, R0
BR callbackasm1(SB)
MOVD $1830, R0
BR callbackasm1(SB)
MOVD $1831, R0
BR callbackasm1(SB)
MOVD $1832, R0
BR callbackasm1(SB)
MOVD $1833, R0
BR callbackasm1(SB)
MOVD $1834, R0
BR callbackasm1(SB)
MOVD $1835, R0
BR callbackasm1(SB)
MOVD $1836, R0
BR callbackasm1(SB)
MOVD $1837, R0
BR callbackasm1(SB)
MOVD $1838, R0
BR callbackasm1(SB)
MOVD $1839, R0
BR callbackasm1(SB)
MOVD $1840, R0
BR callbackasm1(SB)
MOVD $1841, R0
BR callbackasm1(SB)
MOVD $1842, R0
BR callbackasm1(SB)
MOVD $1843, R0
BR callbackasm1(SB)
MOVD $1844, R0
BR callbackasm1(SB)
MOVD $1845, R0
BR callbackasm1(SB)
MOVD $1846, R0
BR callbackasm1(SB)
MOVD $1847, R0
BR callbackasm1(SB)
MOVD $1848, R0
BR callbackasm1(SB)
MOVD $1849, R0
BR callbackasm1(SB)
MOVD $1850, R0
BR callbackasm1(SB)
MOVD $1851, R0
BR callbackasm1(SB)
MOVD $1852, R0
BR callbackasm1(SB)
MOVD $1853, R0
BR callbackasm1(SB)
MOVD $1854, R0
BR callbackasm1(SB)
MOVD $1855, R0
BR callbackasm1(SB)
MOVD $1856, R0
BR callbackasm1(SB)
MOVD $1857, R0
BR callbackasm1(SB)
MOVD $1858, R0
BR callbackasm1(SB)
MOVD $1859, R0
BR callbackasm1(SB)
MOVD $1860, R0
BR callbackasm1(SB)
MOVD $1861, R0
BR callbackasm1(SB)
MOVD $1862, R0
BR callbackasm1(SB)
MOVD $1863, R0
BR callbackasm1(SB)
MOVD $1864, R0
BR callbackasm1(SB)
MOVD $1865, R0
BR callbackasm1(SB)
MOVD $1866, R0
BR callbackasm1(SB)
MOVD $1867, R0
BR callbackasm1(SB)
MOVD $1868, R0
BR callbackasm1(SB)
MOVD $1869, R0
BR callbackasm1(SB)
MOVD $1870, R0
BR callbackasm1(SB)
MOVD $1871, R0
BR callbackasm1(SB)
MOVD $1872, R0
BR callbackasm1(SB)
MOVD $1873, R0
BR callbackasm1(SB)
MOVD $1874, R0
BR callbackasm1(SB)
MOVD $1875, R0
BR callbackasm1(SB)
MOVD $1876, R0
BR callbackasm1(SB)
MOVD $1877, R0
BR callbackasm1(SB)
MOVD $1878, R0
BR callbackasm1(SB)
MOVD $1879, R0
BR callbackasm1(SB)
MOVD $1880, R0
BR callbackasm1(SB)
MOVD $1881, R0
BR callbackasm1(SB)
MOVD $1882, R0
BR callbackasm1(SB)
MOVD $1883, R0
BR callbackasm1(SB)
MOVD $1884, R0
BR callbackasm1(SB)
MOVD $1885, R0
BR callbackasm1(SB)
MOVD $1886, R0
BR callbackasm1(SB)
MOVD $1887, R0
BR callbackasm1(SB)
MOVD $1888, R0
BR callbackasm1(SB)
MOVD $1889, R0
BR callbackasm1(SB)
MOVD $1890, R0
BR callbackasm1(SB)
MOVD $1891, R0
BR callbackasm1(SB)
MOVD $1892, R0
BR callbackasm1(SB)
MOVD $1893, R0
BR callbackasm1(SB)
MOVD $1894, R0
BR callbackasm1(SB)
MOVD $1895, R0
BR callbackasm1(SB)
MOVD $1896, R0
BR callbackasm1(SB)
MOVD $1897, R0
BR callbackasm1(SB)
MOVD $1898, R0
BR callbackasm1(SB)
MOVD $1899, R0
BR callbackasm1(SB)
MOVD $1900, R0
BR callbackasm1(SB)
MOVD $1901, R0
BR callbackasm1(SB)
MOVD $1902, R0
BR callbackasm1(SB)
MOVD $1903, R0
BR callbackasm1(SB)
MOVD $1904, R0
BR callbackasm1(SB)
MOVD $1905, R0
BR callbackasm1(SB)
MOVD $1906, R0
BR callbackasm1(SB)
MOVD $1907, R0
BR callbackasm1(SB)
MOVD $1908, R0
BR callbackasm1(SB)
MOVD $1909, R0
BR callbackasm1(SB)
MOVD $1910, R0
BR callbackasm1(SB)
MOVD $1911, R0
BR callbackasm1(SB)
MOVD $1912, R0
BR callbackasm1(SB)
MOVD $1913, R0
BR callbackasm1(SB)
MOVD $1914, R0
BR callbackasm1(SB)
MOVD $1915, R0
BR callbackasm1(SB)
MOVD $1916, R0
BR callbackasm1(SB)
MOVD $1917, R0
BR callbackasm1(SB)
MOVD $1918, R0
BR callbackasm1(SB)
MOVD $1919, R0
BR callbackasm1(SB)
MOVD $1920, R0
BR callbackasm1(SB)
MOVD $1921, R0
BR callbackasm1(SB)
MOVD $1922, R0
BR callbackasm1(SB)
MOVD $1923, R0
BR callbackasm1(SB)
MOVD $1924, R0
BR callbackasm1(SB)
MOVD $1925, R0
BR callbackasm1(SB)
MOVD $1926, R0
BR callbackasm1(SB)
MOVD $1927, R0
BR callbackasm1(SB)
MOVD $1928, R0
BR callbackasm1(SB)
MOVD $1929, R0
BR callbackasm1(SB)
MOVD $1930, R0
BR callbackasm1(SB)
MOVD $1931, R0
BR callbackasm1(SB)
MOVD $1932, R0
BR callbackasm1(SB)
MOVD $1933, R0
BR callbackasm1(SB)
MOVD $1934, R0
BR callbackasm1(SB)
MOVD $1935, R0
BR callbackasm1(SB)
MOVD $1936, R0
BR callbackasm1(SB)
MOVD $1937, R0
BR callbackasm1(SB)
MOVD $1938, R0
BR callbackasm1(SB)
MOVD $1939, R0
BR callbackasm1(SB)
MOVD $1940, R0
BR callbackasm1(SB)
MOVD $1941, R0
BR callbackasm1(SB)
MOVD $1942, R0
BR callbackasm1(SB)
MOVD $1943, R0
BR callbackasm1(SB)
MOVD $1944, R0
BR callbackasm1(SB)
MOVD $1945, R0
BR callbackasm1(SB)
MOVD $1946, R0
BR callbackasm1(SB)
MOVD $1947, R0
BR callbackasm1(SB)
MOVD $1948, R0
BR callbackasm1(SB)
MOVD $1949, R0
BR callbackasm1(SB)
MOVD $1950, R0
BR callbackasm1(SB)
MOVD $1951, R0
BR callbackasm1(SB)
MOVD $1952, R0
BR callbackasm1(SB)
MOVD $1953, R0
BR callbackasm1(SB)
MOVD $1954, R0
BR callbackasm1(SB)
MOVD $1955, R0
BR callbackasm1(SB)
MOVD $1956, R0
BR callbackasm1(SB)
MOVD $1957, R0
BR callbackasm1(SB)
MOVD $1958, R0
BR callbackasm1(SB)
MOVD $1959, R0
BR callbackasm1(SB)
MOVD $1960, R0
BR callbackasm1(SB)
MOVD $1961, R0
BR callbackasm1(SB)
MOVD $1962, R0
BR callbackasm1(SB)
MOVD $1963, R0
BR callbackasm1(SB)
MOVD $1964, R0
BR callbackasm1(SB)
MOVD $1965, R0
BR callbackasm1(SB)
MOVD $1966, R0
BR callbackasm1(SB)
MOVD $1967, R0
BR callbackasm1(SB)
MOVD $1968, R0
BR callbackasm1(SB)
MOVD $1969, R0
BR callbackasm1(SB)
MOVD $1970, R0
BR callbackasm1(SB)
MOVD $1971, R0
BR callbackasm1(SB)
MOVD $1972, R0
BR callbackasm1(SB)
MOVD $1973, R0
BR callbackasm1(SB)
MOVD $1974, R0
BR callbackasm1(SB)
MOVD $1975, R0
BR callbackasm1(SB)
MOVD $1976, R0
BR callbackasm1(SB)
MOVD $1977, R0
BR callbackasm1(SB)
MOVD $1978, R0
BR callbackasm1(SB)
MOVD $1979, R0
BR callbackasm1(SB)
MOVD $1980, R0
BR callbackasm1(SB)
MOVD $1981, R0
BR callbackasm1(SB)
MOVD $1982, R0
BR callbackasm1(SB)
MOVD $1983, R0
BR callbackasm1(SB)
MOVD $1984, R0
BR callbackasm1(SB)
MOVD $1985, R0
BR callbackasm1(SB)
MOVD $1986, R0
BR callbackasm1(SB)
MOVD $1987, R0
BR callbackasm1(SB)
MOVD $1988, R0
BR callbackasm1(SB)
MOVD $1989, R0
BR callbackasm1(SB)
MOVD $1990, R0
BR callbackasm1(SB)
MOVD $1991, R0
BR callbackasm1(SB)
MOVD $1992, R0
BR callbackasm1(SB)
MOVD $1993, R0
BR callbackasm1(SB)
MOVD $1994, R0
BR callbackasm1(SB)
MOVD $1995, R0
BR callbackasm1(SB)
MOVD $1996, R0
BR callbackasm1(SB)
MOVD $1997, R0
BR callbackasm1(SB)
MOVD $1998, R0
BR callbackasm1(SB)
MOVD $1999, R0
BR callbackasm1(SB)