diff --git a/go.mod b/go.mod index 62e1a476ee..1177f2f380 100644 --- a/go.mod +++ b/go.mod @@ -83,7 +83,7 @@ require ( github.com/spf13/viper v1.21.0 github.com/stretchr/testify v1.11.1 github.com/test-go/testify v1.1.4 - github.com/testcontainers/testcontainers-go v0.40.0 + github.com/testcontainers/testcontainers-go v0.41.0 github.com/testcontainers/testcontainers-go/modules/opensearch v0.40.0 github.com/theckman/yacspin v0.13.12 github.com/thejerf/suture/v4 v4.0.6 @@ -123,7 +123,7 @@ require ( require ( contrib.go.opencensus.io/exporter/prometheus v0.4.2 // indirect filippo.io/edwards25519 v1.1.1 // indirect - github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect + github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect github.com/Azure/go-ntlmssp v0.0.0-20221128193559-754e69321358 // indirect github.com/BurntSushi/toml v1.6.0 // indirect github.com/Masterminds/goutils v1.1.1 // indirect @@ -191,11 +191,11 @@ require ( github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/distribution/reference v0.6.0 // indirect github.com/dlclark/regexp2 v1.4.0 // indirect - github.com/docker/docker v28.5.1+incompatible // indirect + github.com/docker/docker v28.5.2+incompatible // indirect github.com/docker/go-connections v0.6.0 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/ebitengine/purego v0.8.4 // indirect + github.com/ebitengine/purego v0.10.0 // indirect github.com/egirna/icap v0.0.0-20181108071049-d5ee18bd70bc // indirect github.com/emirpasic/gods v1.18.1 // indirect github.com/emvi/iso-639-1 v1.1.1 // indirect @@ -295,12 +295,12 @@ require ( github.com/mitchellh/copystructure v1.2.0 // indirect github.com/mitchellh/reflectwalk v1.0.2 // indirect github.com/moby/docker-image-spec v1.3.1 // indirect - github.com/moby/go-archive v0.1.0 // indirect + github.com/moby/go-archive v0.2.0 // indirect github.com/moby/patternmatcher v0.6.0 // indirect github.com/moby/sys/sequential v0.6.0 // indirect github.com/moby/sys/user v0.4.0 // indirect github.com/moby/sys/userns v0.1.0 // indirect - github.com/moby/term v0.5.0 // indirect + github.com/moby/term v0.5.2 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/morikuni/aec v1.0.0 // indirect @@ -325,7 +325,7 @@ require ( github.com/pierrec/lz4/v4 v4.1.15 // indirect github.com/pjbgf/sha1cd v0.3.2 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect github.com/pquerna/cachecontrol v0.2.0 // indirect github.com/prometheus/alertmanager v0.31.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect @@ -349,7 +349,7 @@ require ( github.com/sethvargo/go-diceware v0.5.0 // indirect github.com/sethvargo/go-password v0.3.1 // indirect github.com/shamaton/msgpack/v2 v2.4.0 // indirect - github.com/shirou/gopsutil/v4 v4.25.6 // indirect + github.com/shirou/gopsutil/v4 v4.26.2 // indirect github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c // indirect github.com/shurcooL/vfsgen v0.0.0-20230704071429-0000e147ea92 // indirect github.com/skeema/knownhosts v1.3.1 // indirect @@ -363,8 +363,8 @@ require ( github.com/tidwall/match v1.1.1 // indirect github.com/tidwall/pretty v1.2.1 // indirect github.com/tinylib/msgp v1.6.1 // indirect - github.com/tklauser/go-sysconf v0.3.14 // indirect - github.com/tklauser/numcpus v0.8.0 // indirect + github.com/tklauser/go-sysconf v0.3.16 // indirect + github.com/tklauser/numcpus v0.11.0 // indirect github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208 // indirect github.com/trustelem/zxcvbn v1.0.1 // indirect github.com/urfave/cli/v2 v2.27.7 // indirect diff --git a/go.sum b/go.sum index f8899d7037..b795973bfa 100644 --- a/go.sum +++ b/go.sum @@ -46,8 +46,8 @@ github.com/Acconut/go-httptest-recorder v1.0.0/go.mod h1:CwQyhTH1kq/gLyWiRieo7c0 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk= github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= github.com/Azure/azure-sdk-for-go v32.4.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/Azure/go-autorest/autorest v0.1.0/go.mod h1:AKyIcETwSUFxIcs/Wnq/C+kwCtlEYGUVd7FPNb2slmg= github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= github.com/Azure/go-autorest/autorest/adal v0.1.0/go.mod h1:MeS4XhScH55IST095THyTxElntu7WqB7pNbZo8Q5G3E= @@ -310,8 +310,8 @@ github.com/dlclark/regexp2 v1.4.0 h1:F1rxgk7p4uKjwIQxBs9oAXe5CqrXlCduYEJvrF4u93E github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E= github.com/dnsimple/dnsimple-go v0.63.0/go.mod h1:O5TJ0/U6r7AfT8niYNlmohpLbCSG+c71tQlGr9SeGrg= -github.com/docker/docker v28.5.1+incompatible h1:Bm8DchhSD2J6PsFzxC35TZo4TLGR2PdW/E69rU45NhM= -github.com/docker/docker v28.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/docker v28.5.2+incompatible h1:DBX0Y0zAjZbSrm1uzOkdr1onVghKaftjlSWt4AFexzM= +github.com/docker/docker v28.5.2+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94= github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE= github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= @@ -323,8 +323,8 @@ github.com/dutchcoders/go-clamd v0.0.0-20170520113014-b970184f4d9e/go.mod h1:Byz github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= -github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw= -github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU= +github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= github.com/egirna/icap v0.0.0-20181108071049-d5ee18bd70bc h1:6IxmRbXV8WXVkcYcTzkU219A3UZeNMX/e6X2sve1wXA= github.com/egirna/icap v0.0.0-20181108071049-d5ee18bd70bc/go.mod h1:FdVN2WHg7zOHhJ7kZQdDorfFhIfqZaHttjAzDDvAXHE= github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= @@ -878,8 +878,8 @@ github.com/mna/pigeon v1.3.0 h1:/3fzVrl1C2RK3x04tyL+ribn+3S3VSEFFbCFLmRPAoc= github.com/mna/pigeon v1.3.0/go.mod h1:SKQNHonx2q9U2QSSoPtMigExj+vQ1mOpL7UVFQF/IA0= github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= -github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ= -github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo= +github.com/moby/go-archive v0.2.0 h1:zg5QDUM2mi0JIM9fdQZWC7U8+2ZfixfTYoHL7rWUcP8= +github.com/moby/go-archive v0.2.0/go.mod h1:mNeivT14o8xU+5q1YnNrkQVpK+dnNe/K6fHqnTg4qPU= github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk= github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw= @@ -890,8 +890,8 @@ github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs= github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs= github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= -github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= -github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ= +github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -1013,8 +1013,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/pquerna/cachecontrol v0.2.0 h1:vBXSNuE5MYP9IJ5kjsdo8uq+w41jSPgvba2DEnkRx9k= github.com/pquerna/cachecontrol v0.2.0/go.mod h1:NrUG3Z7Rdu85UNR3vm7SOsl1nFIeSiQnrHV5K9mBcUI= github.com/pquerna/otp v1.3.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg= @@ -1125,8 +1125,8 @@ github.com/shamaton/msgpack/v2 v2.4.0 h1:O5Z08MRmbo0lA9o2xnQ4TXx6teJbPqEurqcCOQ8 github.com/shamaton/msgpack/v2 v2.4.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI= github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs= -github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c= +github.com/shirou/gopsutil/v4 v4.26.2 h1:X8i6sicvUFih4BmYIGT1m2wwgw2VG9YgrDTi7cIRGUI= +github.com/shirou/gopsutil/v4 v4.26.2/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ= github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c h1:aqg5Vm5dwtvL+YgDpBcK1ITf3o96N/K7/wsRXQnUTEs= github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c/go.mod h1:owqhoLW1qZoYLZzLnBw+QkPP9WZnjlSWihhxAJC1+/M= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= @@ -1202,8 +1202,8 @@ github.com/tchap/go-patricia/v2 v2.3.3 h1:xfNEsODumaEcCcY3gI0hYPZ/PcpVv5ju6RMAhg github.com/tchap/go-patricia/v2 v2.3.3/go.mod h1:VZRHKAb53DLaG+nA9EaYYiaEx6YztwDlLElMsnSHD4k= github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE= github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU= -github.com/testcontainers/testcontainers-go v0.40.0 h1:pSdJYLOVgLE8YdUY2FHQ1Fxu+aMnb6JfVz1mxk7OeMU= -github.com/testcontainers/testcontainers-go v0.40.0/go.mod h1:FSXV5KQtX2HAMlm7U3APNyLkkap35zNLxukw9oBi/MY= +github.com/testcontainers/testcontainers-go v0.41.0 h1:mfpsD0D36YgkxGj2LrIyxuwQ9i2wCKAD+ESsYM1wais= +github.com/testcontainers/testcontainers-go v0.41.0/go.mod h1:pdFrEIfaPl24zmBjerWTTYaY0M6UHsqA1YSvsoU40MI= github.com/testcontainers/testcontainers-go/modules/opensearch v0.40.0 h1:3TIrGk0zXyO9CG2N6APo7auwWIwAvhkwE1reISif8LM= github.com/testcontainers/testcontainers-go/modules/opensearch v0.40.0/go.mod h1:VA0UCTPu+Gcs7MzdzBnSl0qDnxquuphv3ngSGdX97Xs= github.com/thanhpk/randstr v1.0.6 h1:psAOktJFD4vV9NEVb3qkhRSMvYh4ORRaj1+w/hn4B+o= @@ -1224,10 +1224,10 @@ github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= github.com/tinylib/msgp v1.6.1 h1:ESRv8eL3u+DNHUoSAAQRE50Hm162zqAnBoGv9PzScPY= github.com/tinylib/msgp v1.6.1/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= -github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= -github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= -github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= -github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= +github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA= +github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI= +github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw= +github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208 h1:PM5hJF7HVfNWmCjMdEfbuOBNXSVF2cMFGgQTPdKCbwM= github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208/go.mod h1:BzWtXXrXzZUvMacR0oF/fbDDgUPO8L36tDMmRAf14ns= @@ -1319,8 +1319,8 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.41.0 h1:ao6Oe+wSebTlQ1OEht7 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.41.0/go.mod h1:u3T6vz0gh/NVzgDgiwkgLxpsSF6PaPmo2il0apGJbls= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.41.0 h1:mq/Qcf28TWz719lE3/hMB4KkyDuLJIvgJnFGcd0kEUI= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.41.0/go.mod h1:yk5LXEYhsL2htyDNJbEq7fWzNEigeEdV5xBF/Y+kAv0= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.40.0 h1:wVZXIWjQSeSmMoxF74LzAnpVQOAFDo3pPji9Y4SOFKc= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.40.0/go.mod h1:khvBS2IggMFNwZK/6lEeHg/W57h/IX6J4URh57fuI40= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.41.0 h1:inYW9ZhgqiDqh6BioM7DVHHzEGVq76Db5897WLGZ5Go= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.41.0/go.mod h1:Izur+Wt8gClgMJqO/cZ8wdeeMryJ/xxiOVgFSSfpDTY= go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.42.0 h1:s/1iRkCKDfhlh1JF26knRneorus8aOwVIDhvYx9WoDw= go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.42.0/go.mod h1:UI3wi0FXg1Pofb8ZBiBLhtMzgoTm1TYkMvn71fAqDzs= go.opentelemetry.io/otel/metric v1.42.0 h1:2jXG+3oZLNXEPfNmnpxKDeZsFI5o4J+nz6xUlaFdF/4= diff --git a/vendor/github.com/Azure/go-ansiterm/SECURITY.md b/vendor/github.com/Azure/go-ansiterm/SECURITY.md new file mode 100644 index 0000000000..e138ec5d6a --- /dev/null +++ b/vendor/github.com/Azure/go-ansiterm/SECURITY.md @@ -0,0 +1,41 @@ + + +## Security + +Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/). + +If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below. + +## Reporting Security Issues + +**Please do not report security vulnerabilities through public GitHub issues.** + +Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report). + +If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey). + +You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). + +Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: + + * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) + * Full paths of source file(s) related to the manifestation of the issue + * The location of the affected source code (tag/branch/commit or direct URL) + * Any special configuration required to reproduce the issue + * Step-by-step instructions to reproduce the issue + * Proof-of-concept or exploit code (if possible) + * Impact of the issue, including how an attacker might exploit the issue + +This information will help us triage your report more quickly. + +If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs. + +## Preferred Languages + +We prefer all communications to be in English. + +## Policy + +Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd). + + diff --git a/vendor/github.com/Azure/go-ansiterm/osc_string_state.go b/vendor/github.com/Azure/go-ansiterm/osc_string_state.go index 593b10ab69..194d5e9c94 100644 --- a/vendor/github.com/Azure/go-ansiterm/osc_string_state.go +++ b/vendor/github.com/Azure/go-ansiterm/osc_string_state.go @@ -11,21 +11,13 @@ func (oscState oscStringState) Handle(b byte) (s state, e error) { return nextState, err } - switch { - case isOscStringTerminator(b): + // There are several control characters and sequences which can + // terminate an OSC string. Most of them are handled by the baseState + // handler. The ANSI_BEL character is a special case which behaves as a + // terminator only for an OSC string. + if b == ANSI_BEL { return oscState.parser.ground, nil } return oscState, nil } - -// See below for OSC string terminators for linux -// http://man7.org/linux/man-pages/man4/console_codes.4.html -func isOscStringTerminator(b byte) bool { - - if b == ANSI_BEL || b == 0x5C { - return true - } - - return false -} diff --git a/vendor/github.com/docker/docker/api/swagger.yaml b/vendor/github.com/docker/docker/api/swagger.yaml index 6ca2c2b086..feb42e808a 100644 --- a/vendor/github.com/docker/docker/api/swagger.yaml +++ b/vendor/github.com/docker/docker/api/swagger.yaml @@ -2653,14 +2653,6 @@ definitions: description: | Unique ID of the build cache record. example: "ndlpt0hhvkqcdfkputsk4cq9c" - Parent: - description: | - ID of the parent build cache record. - - > **Deprecated**: This field is deprecated, and omitted if empty. - type: "string" - x-nullable: true - example: "" Parents: description: | List of parent build cache record IDs. diff --git a/vendor/github.com/ebitengine/purego/README.md b/vendor/github.com/ebitengine/purego/README.md index f1ff9053ac..8fb85c2caf 100644 --- a/vendor/github.com/ebitengine/purego/README.md +++ b/vendor/github.com/ebitengine/purego/README.md @@ -26,17 +26,36 @@ except for float arguments and return values. ## Supported Platforms -- **FreeBSD**: amd64, arm64 -- **Linux**: amd64, arm64 -- **macOS / iOS**: amd64, arm64 -- **Windows**: 386*, amd64, arm*, arm64 +### Tier 1 -`*` These architectures only support SyscallN and NewCallback +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 Windows and FreeBSD. +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 @@ -84,14 +103,17 @@ License that can be found [in the Go Source](https://github.com/golang/go/blob/m 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/go_GOOS_GOARCH.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)) diff --git a/vendor/github.com/ebitengine/purego/abi_loong64.h b/vendor/github.com/ebitengine/purego/abi_loong64.h new file mode 100644 index 0000000000..b10d83732f --- /dev/null +++ b/vendor/github.com/ebitengine/purego/abi_loong64.h @@ -0,0 +1,60 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/cgo.go b/vendor/github.com/ebitengine/purego/cgo.go index 7d5abef349..b6def570c2 100644 --- a/vendor/github.com/ebitengine/purego/cgo.go +++ b/vendor/github.com/ebitengine/purego/cgo.go @@ -1,14 +1,14 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build cgo && (darwin || freebsd || linux) +//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. +// 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"`! diff --git a/vendor/github.com/ebitengine/purego/dlerror.go b/vendor/github.com/ebitengine/purego/dlerror.go index 95cdfe16f2..ad52b436cd 100644 --- a/vendor/github.com/ebitengine/purego/dlerror.go +++ b/vendor/github.com/ebitengine/purego/dlerror.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors -//go:build darwin || freebsd || linux +//go:build darwin || freebsd || linux || netbsd package purego diff --git a/vendor/github.com/ebitengine/purego/dlfcn.go b/vendor/github.com/ebitengine/purego/dlfcn.go index cd1bf293c7..2730d82cde 100644 --- a/vendor/github.com/ebitengine/purego/dlfcn.go +++ b/vendor/github.com/ebitengine/purego/dlfcn.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build (darwin || freebsd || linux) && !android && !faketime +//go:build (darwin || freebsd || linux || netbsd) && !android && !faketime package purego diff --git a/vendor/github.com/ebitengine/purego/dlfcn_darwin.go b/vendor/github.com/ebitengine/purego/dlfcn_darwin.go index 27f560715a..5dd44468da 100644 --- a/vendor/github.com/ebitengine/purego/dlfcn_darwin.go +++ b/vendor/github.com/ebitengine/purego/dlfcn_darwin.go @@ -17,3 +17,4 @@ const ( //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" diff --git a/vendor/github.com/ebitengine/purego/dlfcn_netbsd.go b/vendor/github.com/ebitengine/purego/dlfcn_netbsd.go new file mode 100644 index 0000000000..220c736762 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/dlfcn_netbsd.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2025 The Ebitengine Authors + +package purego + +// Source for constants: https://github.com/NetBSD/src/blob/trunk/include/dlfcn.h + +const ( + intSize = 32 << (^uint(0) >> 63) // 32 or 64 + RTLD_DEFAULT = 1< int64_t // float32 <=> float // float64 <=> double -// struct <=> struct (WIP - darwin only) +// 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 ...interface{} is like a cast to the function with the arguments inside arg. +// 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 @@ -88,6 +99,9 @@ func RegisterLibFunc(fptr interface{}, handle uintptr, name string) { // 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: @@ -105,7 +119,8 @@ func RegisterLibFunc(fptr interface{}, handle uintptr, name string) { // defer free(mustFree) // // [Cgo rules]: https://pkg.go.dev/cmd/cgo#hdr-Go_references_to_C -func RegisterFunc(fptr interface{}, cfn uintptr) { +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 { @@ -118,7 +133,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { panic("purego: cfn is nil") } if ty.NumOut() == 1 && (ty.Out(0).Kind() == reflect.Float32 || ty.Out(0).Kind() == reflect.Float64) && - runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" { + 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") } { @@ -152,19 +167,13 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { stack++ } case reflect.Float32, reflect.Float64: - const is32bit = unsafe.Sizeof(uintptr(0)) == 4 - if is32bit { - panic("purego: floats only supported on 64bit platforms") - } - if floats < numOfFloats { + if floats < numOfFloatRegisters() { floats++ } else { stack++ } case reflect.Struct: - if runtime.GOOS != "darwin" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") { - panic("purego: struct arguments are only supported on darwin amd64 & arm64") - } + ensureStructSupportedForRegisterFunc() if arg.Size() == 0 { continue } @@ -183,9 +192,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { } } if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { - if runtime.GOOS != "darwin" { - panic("purego: struct return values only supported on darwin arm64 & amd64") - } + ensureStructSupportedForRegisterFunc() outType := ty.Out(0) checkStructFieldsSupported(outType) if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize { @@ -194,27 +201,29 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { ints++ } } + sizeOfStack := maxArgs - numOfIntegerRegisters() - if stack > sizeOfStack { - panic("purego: too many arguments") - } - } - v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) { - if len(args) > 0 { - if variadic, ok := args[len(args)-1].Interface().([]interface{}); ok { - // subtract one from args bc the last argument in args is []interface{} - // which we are currently expanding - tmp := make([]reflect.Value, len(args)-1+len(variadic)) - n := copy(tmp, args[:len(args)-1]) - for i, v := range variadic { - tmp[n+i] = reflect.ValueOf(v) - } - args = tmp + // 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 - stack := sysargs[numOfIntegerRegisters():] - var floats [numOfFloats]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 @@ -222,7 +231,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { // Windows arm64 uses the same calling convention as macOS and Linux addStack = func(x uintptr) { - stack[numStack] = x + sysargs[numOfIntegerRegisters()+numStack] = x numStack++ } addInt = func(x uintptr) { @@ -234,7 +243,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { } } addFloat = func(x uintptr) { - if numFloats < len(floats) { + if numFloats < numOfFloatRegisters() { floats[numFloats] = x numFloats++ } else { @@ -255,15 +264,16 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { addFloat = addStack } - var keepAlive []interface{} + var keepAlive []any defer func() { runtime.KeepAlive(keepAlive) runtime.KeepAlive(args) }() - var syscall syscall15Args + + var arm64_r8 uintptr if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { outType := ty.Out(0) - if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize { + 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()) @@ -272,53 +282,46 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { if !isAllFloats || numFields > 4 { val := reflect.New(outType) keepAlive = append(keepAlive, val) - syscall.arm64_r8 = val.Pointer() + arm64_r8 = val.Pointer() } } } - for _, v := range args { - 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) + 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") } - case reflect.Float32: - addFloat(uintptr(math.Float32bits(float32(v.Float())))) - case reflect.Float64: - 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()) + 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) } - if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { + + syscall := thePool.Get().(*syscall15Args) + defer thePool.Put(syscall) + + 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 = syscall15Args{ - 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], - floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7], - syscall.arm64_r8, - } - runtime_cgocall(syscall15XABI0, unsafe.Pointer(&syscall)) + syscall.Set(cfn, sysargs[:], floats[:], arm64_r8) + runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) } else { + *syscall = syscall15Args{} // 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], @@ -351,21 +354,89 @@ func RegisterFunc(fptr interface{}, cfn uintptr) { 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. - v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1)))) + // 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. - v.SetFloat(math.Float64frombits(uint64(syscall.f1))) + 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) + v = getStruct(outType, *syscall) default: panic("purego: unsupported return kind: " + outType.Kind().String()) } - return []reflect.Value{v} + 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. @@ -411,26 +482,90 @@ func checkStructFieldsSupported(ty reflect.Type) { 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.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 + 7) &^ 7 + 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": + 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 +} diff --git a/vendor/github.com/ebitengine/purego/gen.go b/vendor/github.com/ebitengine/purego/gen.go new file mode 100644 index 0000000000..9cb7c45356 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/gen.go @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2025 The Ebitengine Authors + +package purego + +//go:generate go run wincallback.go diff --git a/vendor/github.com/ebitengine/purego/go_runtime.go b/vendor/github.com/ebitengine/purego/go_runtime.go index 13671ff23f..b327f78691 100644 --- a/vendor/github.com/ebitengine/purego/go_runtime.go +++ b/vendor/github.com/ebitengine/purego/go_runtime.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build darwin || freebsd || linux || windows +//go:build darwin || freebsd || linux || netbsd || windows package purego diff --git a/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go b/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go index b09ecac1cf..6d0571abbd 100644 --- a/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go +++ b/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go @@ -1,12 +1,12 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors -//go:build freebsd || linux +//go:build freebsd || linux || netbsd package cgo /* - #cgo LDFLAGS: -ldl +#cgo !netbsd LDFLAGS: -ldl #include #include diff --git a/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go b/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go index 37ff24d5c1..1e39de3b67 100644 --- a/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go +++ b/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build freebsd || (linux && !(arm64 || amd64)) +//go:build freebsd || (linux && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64)) || netbsd package cgo @@ -9,7 +9,7 @@ package cgo // because Cgo and assembly files can't be in the same package. /* - #cgo LDFLAGS: -ldl +#cgo !netbsd LDFLAGS: -ldl #include #include diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h new file mode 100644 index 0000000000..b10d83732f --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h @@ -0,0 +1,60 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h new file mode 100644 index 0000000000..245a5266f6 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h @@ -0,0 +1,195 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s new file mode 100644 index 0000000000..7475ec8a0b --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s @@ -0,0 +1,29 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s new file mode 100644 index 0000000000..68034e6035 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s @@ -0,0 +1,52 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s new file mode 100644 index 0000000000..e81df86a56 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s @@ -0,0 +1,40 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s new file mode 100644 index 0000000000..6d1938cd8d --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s @@ -0,0 +1,82 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s new file mode 100644 index 0000000000..acf82c1b5a --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s @@ -0,0 +1,78 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s new file mode 100644 index 0000000000..b64466501d --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s @@ -0,0 +1,55 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go index f29e690cc1..27d4c98c8c 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go @@ -2,7 +2,7 @@ // 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) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go index be82f7dfca..e482c120c6 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//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. diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go new file mode 100644 index 0000000000..384dab2a69 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go @@ -0,0 +1,14 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_arm64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go similarity index 100% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_arm64.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_amd64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_amd64.go deleted file mode 100644 index 39f5ff1f06..0000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_amd64.go +++ /dev/null @@ -1,73 +0,0 @@ -// 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) - - 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 -//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)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_arm64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go similarity index 94% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_arm64.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go index e3a060b935..a3ba6bc822 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_arm64.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go @@ -92,6 +92,8 @@ func x_cgo_init(g *G, setg uintptr) { } 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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go index e5a66f39d4..0c46306697 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_arm64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go similarity index 94% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_arm64.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go index a3b1cca59a..9f380c1b43 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_arm64.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go @@ -92,6 +92,8 @@ func x_cgo_init(g *G, setg uintptr) { } 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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_amd64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_amd64.go deleted file mode 100644 index c9ff7156a8..0000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_amd64.go +++ /dev/null @@ -1,95 +0,0 @@ -// 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 - -//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)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_amd64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go similarity index 82% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_amd64.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go index c9ff7156a8..935a334f22 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_amd64.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build !cgo +//go:build !cgo && (amd64 || arm64) package fakecgo @@ -16,7 +16,7 @@ func _cgo_sys_thread_start(ts *ThreadStart) { 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 + // 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) @@ -44,9 +44,20 @@ 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 :) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go index e42d84f0b7..dfc6629e4d 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go index 0ac10d1f15..ee993baae4 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo @@ -28,8 +28,9 @@ func x_cgo_thread_start(arg *ThreadStart) { abort() } // *ts = *arg would cause a writebarrier so copy using slices - s1 := unsafe.Slice((*uintptr)(unsafe.Pointer(ts)), unsafe.Sizeof(*ts)/8) - s2 := unsafe.Slice((*uintptr)(unsafe.Pointer(arg)), unsafe.Sizeof(*arg)/8) + 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] } diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go index 28af41cc64..12e5214703 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go @@ -2,7 +2,7 @@ // 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) +//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. diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go index 38f9441939..94fd8beabc 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go index af148333f6..ecdcb2e785 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go @@ -20,3 +20,7 @@ var ( PTHREAD_COND_INITIALIZER = pthread_cond_t{sig: 0x3CB0B1BB} PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{sig: 0x32AAABA7} ) + +type stack_t struct { + /* not implemented */ +} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go index ca1f722c93..4bfb70c3d5 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go @@ -14,3 +14,7 @@ var ( PTHREAD_COND_INITIALIZER = pthread_cond_t(0) PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0) ) + +type stack_t struct { + /* not implemented */ +} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go index c4b6e9ea5a..b08a44a100 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go @@ -14,3 +14,7 @@ var ( PTHREAD_COND_INITIALIZER = pthread_cond_t{} PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{} ) + +type stack_t struct { + /* not implemented */ +} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go new file mode 100644 index 0000000000..650f6953e3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go @@ -0,0 +1,26 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go new file mode 100644 index 0000000000..2d499814f3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go @@ -0,0 +1,23 @@ +// 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 +) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go index f30af0e151..82308b8cac 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go @@ -2,7 +2,7 @@ // 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) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s new file mode 100644 index 0000000000..cd3492ea77 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s @@ -0,0 +1,107 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s index c9a3cc09eb..e4e4c75a37 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s @@ -7,12 +7,6 @@ trampoline for emulating required C functions for cgo in go (see cgo.go) (we convert cdecl calling convention to go and vice-versa) -Since we're called from go and call into C we can cheat a bit with the calling conventions: - - in go all the registers are caller saved - - in C we have a couple of callee saved registers - -=> we can use BX, R12, R13, R14, R15 instead of the stack - C Calling convention cdecl used here (we only need integer args): 1. arg: DI 2. arg: SI @@ -22,66 +16,75 @@ C Calling convention cdecl used here (we only need integer args): 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), DX - MOVQ (DX), CX - CALL CX + 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), DX - MOVQ (DX), CX - CALL CX + 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), DX - MOVQ (DX), CX - CALL CX + 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), DX - MOVQ (DX), CX - CALL CX + MOVQ ·x_cgo_unsetenv_call(SB), R11 + MOVQ (R11), R11 + CALL R11 RET TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET + JMP ·x_cgo_notify_runtime_init_done(SB) TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET + 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), BX + MOVQ setg+0(FP), R11 XORL AX, AX - CALL BX + CALL R11 RET -TEXT threadentry_trampoline(SB), NOSPLIT, $16 +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), DX - MOVQ (DX), CX - CALL CX + 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), BX + MOVQ fn+0(FP), R11 MOVQ a1+8(FP), DI MOVQ a2+16(FP), SI MOVQ a3+24(FP), DX @@ -95,7 +98,7 @@ TEXT ·call5(SB), NOSPLIT, $0-56 SUBQ $16, SP // allocate space for alignment ANDQ $-16, SP // align on 16 bytes for SSE - CALL BX + CALL R11 MOVQ BP, SP // get SP back POPQ BP // restore BP diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s new file mode 100644 index 0000000000..00b3177ef4 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s @@ -0,0 +1,81 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s index 9dbdbc0139..dceb1cac6e 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s @@ -5,36 +5,34 @@ #include "textflag.h" #include "go_asm.h" +#include "abi_arm64.h" -// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. +// 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 R0, 8(RSP) - MOVD R1, 16(RSP) - MOVD ·x_cgo_init_call(SB), R26 - MOVD (R26), R2 - CALL (R2) + MOVD ·x_cgo_init_call(SB), R9 + MOVD (R9), R9 + CALL R9 RET TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $0-0 - MOVD R0, 8(RSP) - MOVD ·x_cgo_thread_start_call(SB), R26 - MOVD (R26), R2 - CALL (R2) + MOVD ·x_cgo_thread_start_call(SB), R9 + MOVD (R9), R9 + CALL R9 RET TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $0-0 - MOVD R0, 8(RSP) - MOVD ·x_cgo_setenv_call(SB), R26 - MOVD (R26), R2 - CALL (R2) + MOVD ·x_cgo_setenv_call(SB), R9 + MOVD (R9), R9 + CALL R9 RET TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $0-0 - MOVD R0, 8(RSP) - MOVD ·x_cgo_unsetenv_call(SB), R26 - MOVD (R26), R2 - CALL (R2) + 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 @@ -48,25 +46,39 @@ TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 // func setg_trampoline(setg uintptr, g uintptr) TEXT ·setg_trampoline(SB), NOSPLIT, $0-16 MOVD G+8(FP), R0 - MOVD setg+0(FP), R1 - CALL R1 + MOVD setg+0(FP), R9 + CALL R9 RET TEXT threadentry_trampoline(SB), NOSPLIT, $0-0 - MOVD R0, 8(RSP) - MOVD ·threadentry_call(SB), R26 - MOVD (R26), R2 - CALL (R2) - MOVD $0, R0 // TODO: get the return value from threadentry + // 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), R6 + 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 R6 + CALL R9 MOVD R0, ret+48(FP) RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s new file mode 100644 index 0000000000..7596f0da16 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s @@ -0,0 +1,88 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s new file mode 100644 index 0000000000..85f895564d --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s @@ -0,0 +1,227 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s new file mode 100644 index 0000000000..9298f8c71a --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s @@ -0,0 +1,72 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go similarity index 70% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go index d517024001..cc552e7d30 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go @@ -3,7 +3,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo @@ -12,12 +12,6 @@ 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 - //go:nosplit //go:norace func malloc(size uintptr) unsafe.Pointer { @@ -86,36 +80,6 @@ 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_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_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_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: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:nosplit //go:norace func pthread_mutex_lock(mutex *pthread_mutex_t) int32 { @@ -184,26 +148,6 @@ var pthread_detachABI0 = uintptr(unsafe.Pointer(&_pthread_detach)) var _pthread_sigmask uint8 var pthread_sigmaskABI0 = uintptr(unsafe.Pointer(&_pthread_sigmask)) -//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_getstacksize _pthread_attr_getstacksize -var _pthread_attr_getstacksize uint8 -var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize)) - -//go:linkname _pthread_attr_setstacksize _pthread_attr_setstacksize -var _pthread_attr_setstacksize uint8 -var pthread_attr_setstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_setstacksize)) - -//go:linkname _pthread_attr_destroy _pthread_attr_destroy -var _pthread_attr_destroy uint8 -var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy)) - //go:linkname _pthread_mutex_lock _pthread_mutex_lock var _pthread_mutex_lock uint8 var pthread_mutex_lockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_lock)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_darwin.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go similarity index 63% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_darwin.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go index 54aaa46285..960f8168eb 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_darwin.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go @@ -7,6 +7,8 @@ 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" @@ -18,12 +20,40 @@ package fakecgo //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_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_getstacksize pthread_attr_getstacksize "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "/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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go similarity index 64% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_freebsd.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go index 8153811979..d69775596f 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_freebsd.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go @@ -7,6 +7,8 @@ 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" @@ -18,12 +20,29 @@ package fakecgo //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_self pthread_self "libpthread.so" -//go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_linux.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go similarity index 65% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_linux.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go index 180057d015..f6bad22c34 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_linux.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go @@ -7,6 +7,8 @@ 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" @@ -18,12 +20,29 @@ package fakecgo //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_self pthread_self "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go new file mode 100644 index 0000000000..774402cfb8 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go @@ -0,0 +1,59 @@ +// 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)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s new file mode 100644 index 0000000000..35ef7ac11c --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s @@ -0,0 +1,19 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s new file mode 100644 index 0000000000..da07005c0b --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s @@ -0,0 +1,16 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s new file mode 100644 index 0000000000..da07005c0b --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s @@ -0,0 +1,16 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s new file mode 100644 index 0000000000..81ef76f59c --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s @@ -0,0 +1,19 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_stubs.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s similarity index 67% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_stubs.s rename to vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s index a65b2012c1..8e1afff734 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_stubs.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s @@ -3,88 +3,53 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//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 on darwin arm64 +// 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) - RET TEXT _free(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_free(SB) - RET TEXT _setenv(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_setenv(SB) - RET TEXT _unsetenv(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_unsetenv(SB) - RET TEXT _sigfillset(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_sigfillset(SB) - RET TEXT _nanosleep(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_nanosleep(SB) - RET TEXT _abort(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_abort(SB) - RET TEXT _pthread_attr_init(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_attr_init(SB) - RET TEXT _pthread_create(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_create(SB) - RET TEXT _pthread_detach(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_detach(SB) - RET TEXT _pthread_sigmask(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_sigmask(SB) - RET - -TEXT _pthread_self(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_self(SB) - RET - -TEXT _pthread_get_stacksize_np(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_get_stacksize_np(SB) - RET - -TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_getstacksize(SB) - RET - -TEXT _pthread_attr_setstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_setstacksize(SB) - RET - -TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_destroy(SB) - RET TEXT _pthread_mutex_lock(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_mutex_lock(SB) - RET TEXT _pthread_mutex_unlock(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_mutex_unlock(SB) - RET TEXT _pthread_cond_broadcast(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_cond_broadcast(SB) - RET TEXT _pthread_setspecific(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_setspecific(SB) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go new file mode 100644 index 0000000000..5eb0580e02 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go @@ -0,0 +1,15 @@ +// 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 +} diff --git a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go new file mode 100644 index 0000000000..62ee13d6c3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go @@ -0,0 +1,12 @@ +// 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) +} diff --git a/vendor/github.com/ebitengine/purego/nocgo.go b/vendor/github.com/ebitengine/purego/nocgo.go index 5b989ea814..b91b9796b9 100644 --- a/vendor/github.com/ebitengine/purego/nocgo.go +++ b/vendor/github.com/ebitengine/purego/nocgo.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build !cgo && (darwin || freebsd || linux) +//go:build !cgo && (darwin || freebsd || linux || netbsd) package purego diff --git a/vendor/github.com/ebitengine/purego/struct_386.go b/vendor/github.com/ebitengine/purego/struct_386.go new file mode 100644 index 0000000000..02c8ac45ce --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_386.go @@ -0,0 +1,41 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_amd64.go b/vendor/github.com/ebitengine/purego/struct_amd64.go index f3514c984e..c56f957af2 100644 --- a/vendor/github.com/ebitengine/purego/struct_amd64.go +++ b/vendor/github.com/ebitengine/purego/struct_amd64.go @@ -85,7 +85,7 @@ const ( _MEMORY = 0b1111 ) -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []interface{}) []interface{} { +func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { if v.Type().Size() == 0 { return keepAlive } @@ -120,7 +120,7 @@ func postMerger(t reflect.Type) (passInMemory bool) { if t.Size() <= 2*8 { return false } - return true // Go does not have an SSE/SEEUP type so this is always true + 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) { @@ -165,13 +165,14 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp place(f) case reflect.Bool: if f.Bool() { - val |= 1 + val |= 1 << shift } shift += 8 class |= _INTEGER - case reflect.Pointer: - ok = false - return + case reflect.Pointer, reflect.UnsafePointer: + val = uint64(f.Pointer()) + shift = 64 + class = _INTEGER case reflect.Int8: val |= uint64(f.Int()&0xFF) << shift shift += 8 @@ -200,7 +201,7 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp val |= f.Uint() << shift shift += 32 class |= _INTEGER - case reflect.Uint64, reflect.Uint: + case reflect.Uint64, reflect.Uint, reflect.Uintptr: val = f.Uint() shift = 64 class = _INTEGER @@ -238,23 +239,48 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp } func placeStack(v reflect.Value, addStack func(uintptr)) { - for i := 0; i < v.Type().NumField(); i++ { - f := v.Field(i) - switch f.Kind() { - case reflect.Pointer: - addStack(f.Pointer()) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - addStack(uintptr(f.Int())) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - addStack(uintptr(f.Uint())) - case reflect.Float32: - addStack(uintptr(math.Float32bits(float32(f.Float())))) - case reflect.Float64: - addStack(uintptr(math.Float64bits(f.Float()))) - case reflect.Struct: - placeStack(f, addStack) - default: - panic("purego: unsupported kind " + f.Kind().String()) - } + // 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_arm.go b/vendor/github.com/ebitengine/purego/struct_arm.go new file mode 100644 index 0000000000..1b580585d3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_arm.go @@ -0,0 +1,85 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_arm64.go b/vendor/github.com/ebitengine/purego/struct_arm64.go index 11c36bd6e4..5f347c83d0 100644 --- a/vendor/github.com/ebitengine/purego/struct_arm64.go +++ b/vendor/github.com/ebitengine/purego/struct_arm64.go @@ -6,7 +6,12 @@ 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) { @@ -65,7 +70,7 @@ const ( _INT = 0b11 ) -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []interface{}) []interface{} { +func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { if v.Type().Size() == 0 { return keepAlive } @@ -73,8 +78,8 @@ func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFl 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() > numOfFloats { - *numFloats = numOfFloats + if hfa && *numFloats+v.NumField() > numOfFloatRegisters() { + *numFloats = numOfFloatRegisters() } else if hva && *numInts+v.NumField() > numOfIntegerRegisters() { *numInts = numOfIntegerRegisters() } @@ -87,6 +92,14 @@ func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFl } 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 @@ -107,6 +120,8 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr } else { f = v.Index(k) } + align := byte(f.Type().Align()*8 - 1) + shift = (shift + align) &^ align if shift >= 64 { shift = 0 flushed = true @@ -115,13 +130,15 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr } 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 + val |= 1 << shift } shift += 8 class |= _INT @@ -137,10 +154,11 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr val |= f.Uint() << shift shift += 32 class |= _INT - case reflect.Uint64: + 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 @@ -153,10 +171,11 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr val |= uint64(f.Int()&0xFFFF_FFFF) << shift shift += 32 class |= _INT - case reflect.Int64: + 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)) @@ -170,6 +189,12 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr 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: @@ -187,7 +212,7 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr } } -func placeStack(v reflect.Value, keepAlive []interface{}, addInt func(uintptr)) []interface{} { +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()) @@ -272,3 +297,253 @@ func isHVA(t reflect.Type) bool { 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) +} diff --git a/vendor/github.com/ebitengine/purego/struct_loong64.go b/vendor/github.com/ebitengine/purego/struct_loong64.go new file mode 100644 index 0000000000..e5891401c9 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_loong64.go @@ -0,0 +1,213 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_other.go b/vendor/github.com/ebitengine/purego/struct_other.go deleted file mode 100644 index 9d42adac89..0000000000 --- a/vendor/github.com/ebitengine/purego/struct_other.go +++ /dev/null @@ -1,16 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -//go:build !amd64 && !arm64 - -package purego - -import "reflect" - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []interface{}) []interface{} { - panic("purego: struct arguments are not supported") -} - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - panic("purego: struct returns are not supported") -} diff --git a/vendor/github.com/ebitengine/purego/struct_ppc64le.go b/vendor/github.com/ebitengine/purego/struct_ppc64le.go new file mode 100644 index 0000000000..7c50dcbba9 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_ppc64le.go @@ -0,0 +1,143 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_riscv64.go b/vendor/github.com/ebitengine/purego/struct_riscv64.go new file mode 100644 index 0000000000..eac0b88023 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_riscv64.go @@ -0,0 +1,143 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/struct_s390x.go b/vendor/github.com/ebitengine/purego/struct_s390x.go new file mode 100644 index 0000000000..7ec5e813cf --- /dev/null +++ b/vendor/github.com/ebitengine/purego/struct_s390x.go @@ -0,0 +1,143 @@ +// 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") +} diff --git a/vendor/github.com/ebitengine/purego/sys_386.s b/vendor/github.com/ebitengine/purego/sys_386.s new file mode 100644 index 0000000000..82931413e0 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_386.s @@ -0,0 +1,147 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_amd64.s b/vendor/github.com/ebitengine/purego/sys_amd64.s index cabde1a584..15b24dd296 100644 --- a/vendor/github.com/ebitengine/purego/sys_amd64.s +++ b/vendor/github.com/ebitengine/purego/sys_amd64.s @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build darwin || freebsd || linux +//go:build darwin || freebsd || linux || netbsd #include "textflag.h" #include "abi_amd64.h" @@ -91,6 +91,12 @@ TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0 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 diff --git a/vendor/github.com/ebitengine/purego/sys_arm.s b/vendor/github.com/ebitengine/purego/sys_arm.s new file mode 100644 index 0000000000..3a8ce0d0d3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_arm.s @@ -0,0 +1,142 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/sys_arm64.s b/vendor/github.com/ebitengine/purego/sys_arm64.s index a68fdb99ba..40a2f4c1db 100644 --- a/vendor/github.com/ebitengine/purego/sys_arm64.s +++ b/vendor/github.com/ebitengine/purego/sys_arm64.s @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build darwin || freebsd || linux || windows +//go:build darwin || freebsd || linux || netbsd || windows #include "textflag.h" #include "go_asm.h" @@ -89,4 +89,9 @@ TEXT syscall15X(SB), NOSPLIT, $0 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 diff --git a/vendor/github.com/ebitengine/purego/sys_loong64.s b/vendor/github.com/ebitengine/purego/sys_loong64.s new file mode 100644 index 0000000000..420b855c23 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_loong64.s @@ -0,0 +1,96 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_ppc64le.s b/vendor/github.com/ebitengine/purego/sys_ppc64le.s new file mode 100644 index 0000000000..391b30a958 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_ppc64le.s @@ -0,0 +1,120 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_riscv64.s b/vendor/github.com/ebitengine/purego/sys_riscv64.s new file mode 100644 index 0000000000..e7e887e155 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_riscv64.s @@ -0,0 +1,101 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_s390x.s b/vendor/github.com/ebitengine/purego/sys_s390x.s new file mode 100644 index 0000000000..a044e34d33 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_s390x.s @@ -0,0 +1,114 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_386.s b/vendor/github.com/ebitengine/purego/sys_unix_386.s new file mode 100644 index 0000000000..31aecbf3cd --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_386.s @@ -0,0 +1,226 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_arm.s b/vendor/github.com/ebitengine/purego/sys_unix_arm.s new file mode 100644 index 0000000000..a97e9437dd --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_arm.s @@ -0,0 +1,89 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_arm64.s b/vendor/github.com/ebitengine/purego/sys_unix_arm64.s index 6da06b4d18..cea803ef9a 100644 --- a/vendor/github.com/ebitengine/purego/sys_unix_arm64.s +++ b/vendor/github.com/ebitengine/purego/sys_unix_arm64.s @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors -//go:build darwin || freebsd || linux +//go:build darwin || freebsd || linux || netbsd #include "textflag.h" #include "go_asm.h" diff --git a/vendor/github.com/ebitengine/purego/sys_unix_loong64.s b/vendor/github.com/ebitengine/purego/sys_unix_loong64.s new file mode 100644 index 0000000000..cd00f9c1a1 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_loong64.s @@ -0,0 +1,75 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s b/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s new file mode 100644 index 0000000000..37f0d8d601 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s @@ -0,0 +1,114 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s b/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s new file mode 100644 index 0000000000..8341d5b08e --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s @@ -0,0 +1,79 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/sys_unix_s390x.s b/vendor/github.com/ebitengine/purego/sys_unix_s390x.s new file mode 100644 index 0000000000..9eed6d29c3 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/sys_unix_s390x.s @@ -0,0 +1,109 @@ +// 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 diff --git a/vendor/github.com/ebitengine/purego/syscall.go b/vendor/github.com/ebitengine/purego/syscall.go index c30688dda1..7b45383d34 100644 --- a/vendor/github.com/ebitengine/purego/syscall.go +++ b/vendor/github.com/ebitengine/purego/syscall.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build darwin || freebsd || linux || windows +//go:build !386 && !arm && (darwin || freebsd || linux || netbsd || windows) package purego @@ -13,8 +13,7 @@ package purego type CDecl struct{} const ( - maxArgs = 15 - numOfFloats = 8 // arm64 and amd64 both have 8 float registers + maxArgs = 15 ) type syscall15Args struct { @@ -23,10 +22,41 @@ type syscall15Args struct { 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. diff --git a/vendor/github.com/ebitengine/purego/syscall_32bit.go b/vendor/github.com/ebitengine/purego/syscall_32bit.go new file mode 100644 index 0000000000..f9f3763030 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/syscall_32bit.go @@ -0,0 +1,109 @@ +// 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]) +} diff --git a/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go b/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go index 36ee14e3b7..179167f4b4 100644 --- a/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go +++ b/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build cgo && !(amd64 || arm64) +//go:build cgo && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || s390x) package purego @@ -16,6 +16,6 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) } -func NewCallback(_ interface{}) uintptr { - panic("purego: NewCallback on Linux is only supported on amd64/arm64") +func NewCallback(_ any) uintptr { + panic("purego: NewCallback on Linux is only supported on 386/amd64/arm64/arm/loong64/ppc64le/riscv64/s390x") } diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv.go b/vendor/github.com/ebitengine/purego/syscall_sysv.go index cce171c8f6..e35b32e71d 100644 --- a/vendor/github.com/ebitengine/purego/syscall_sysv.go +++ b/vendor/github.com/ebitengine/purego/syscall_sysv.go @@ -1,7 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors -//go:build darwin || freebsd || (linux && (amd64 || arm64)) +// 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 @@ -14,15 +15,19 @@ import ( var syscall15XABI0 uintptr -//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) { - args := syscall15Args{ - fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, - a1, a2, a3, a4, a5, a6, a7, a8, - 0, + args := thePool.Get().(*syscall15Args) + defer thePool.Put(args) + + *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, 0 + + 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. @@ -31,7 +36,7 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a // 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 interface{}) uintptr { +func NewCallback(fn any) uintptr { ty := reflect.TypeOf(fn) for i := 0; i < ty.NumIn(); i++ { in := ty.In(i) @@ -55,23 +60,7 @@ var cbs struct { funcs [maxCB]reflect.Value // the saved callbacks } -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 compileCallback(fn interface{}) uintptr { +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") @@ -142,38 +131,95 @@ func callbackWrap(a *callbackArgs) { fnType := fn.Type() args := make([]reflect.Value, fnType.NumIn()) frame := (*[callbackMaxFrame]uintptr)(a.args) - var floatsN int // floatsN represents the number of float arguments processed - var intsN int // intsN represents the number of integer arguments processed - // stack points to the index into frame of the current stack element. - // The stack begins after the float and integer registers. - stack := numOfIntegerRegisters() + numOfFloats + // 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 { - var pos int - switch fnType.In(i).Kind() { + // 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: - if floatsN >= numOfFloats { - pos = stack - stack++ + 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 { - pos = floatsN + 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++ + floatsN += slots case reflect.Struct: // This is the CDecl field - args[i] = reflect.Zero(fnType.In(i)) - continue + args[i] = reflect.Zero(inType) default: - - if intsN >= numOfIntegerRegisters() { - pos = stack - stack++ + 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 + numOfFloats + 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++ + intsN += slots } - args[i] = reflect.NewAt(fnType.In(i), unsafe.Pointer(&frame[pos])).Elem() } ret := fn.Call(args) if len(ret) > 0 { @@ -198,6 +244,50 @@ func callbackWrap(a *callbackArgs) { } } +// 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, @@ -212,12 +302,19 @@ func callbackasmAddr(i int) uintptr { switch runtime.GOARCH { default: panic("purego: unsupported architecture") - case "386", "amd64": + case "amd64": + // On amd64, each callback entry is just a CALL instruction (5 bytes) entrySize = 5 - case "arm", "arm64": - // On ARM and ARM64, each entry is a MOV instruction + 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) } diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv_others.go b/vendor/github.com/ebitengine/purego/syscall_sysv_others.go new file mode 100644 index 0000000000..d4f6c7b7fb --- /dev/null +++ b/vendor/github.com/ebitengine/purego/syscall_sysv_others.go @@ -0,0 +1,28 @@ +// 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 +} diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go b/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go new file mode 100644 index 0000000000..87ed981119 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go @@ -0,0 +1,33 @@ +// 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 +} diff --git a/vendor/github.com/ebitengine/purego/syscall_windows.go b/vendor/github.com/ebitengine/purego/syscall_windows.go index 5fbfcabfdc..5afd8d83ca 100644 --- a/vendor/github.com/ebitengine/purego/syscall_windows.go +++ b/vendor/github.com/ebitengine/purego/syscall_windows.go @@ -22,7 +22,7 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a // 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 interface{}) uintptr { +func NewCallback(fn any) uintptr { isCDecl := false ty := reflect.TypeOf(fn) for i := 0; i < ty.NumIn(); i++ { diff --git a/vendor/github.com/ebitengine/purego/zcallback_386.s b/vendor/github.com/ebitengine/purego/zcallback_386.s new file mode 100644 index 0000000000..bd2d9c85ac --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_386.s @@ -0,0 +1,4014 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/zcallback_amd64.s b/vendor/github.com/ebitengine/purego/zcallback_amd64.s index 6a778bfcad..b2da022556 100644 --- a/vendor/github.com/ebitengine/purego/zcallback_amd64.s +++ b/vendor/github.com/ebitengine/purego/zcallback_amd64.s @@ -1,6 +1,6 @@ // Code generated by wincallback.go using 'go generate'. DO NOT EDIT. -//go:build darwin || freebsd || linux +//go:build darwin || freebsd || linux || netbsd // runtime·callbackasm is called by external code to // execute Go implemented callback function. It is not diff --git a/vendor/github.com/ebitengine/purego/zcallback_arm.s b/vendor/github.com/ebitengine/purego/zcallback_arm.s new file mode 100644 index 0000000000..d969d81d01 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_arm.s @@ -0,0 +1,4014 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/zcallback_arm64.s b/vendor/github.com/ebitengine/purego/zcallback_arm64.s index c079b8038e..3fea4af8b3 100644 --- a/vendor/github.com/ebitengine/purego/zcallback_arm64.s +++ b/vendor/github.com/ebitengine/purego/zcallback_arm64.s @@ -1,6 +1,6 @@ // Code generated by wincallback.go using 'go generate'. DO NOT EDIT. -//go:build darwin || freebsd || linux +//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. diff --git a/vendor/github.com/ebitengine/purego/zcallback_loong64.s b/vendor/github.com/ebitengine/purego/zcallback_loong64.s new file mode 100644 index 0000000000..c5dcd48e52 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_loong64.s @@ -0,0 +1,4014 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s b/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s new file mode 100644 index 0000000000..702243b1e5 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s @@ -0,0 +1,4014 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/zcallback_riscv64.s b/vendor/github.com/ebitengine/purego/zcallback_riscv64.s new file mode 100644 index 0000000000..f341a87eef --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_riscv64.s @@ -0,0 +1,4051 @@ +// 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) diff --git a/vendor/github.com/ebitengine/purego/zcallback_s390x.s b/vendor/github.com/ebitengine/purego/zcallback_s390x.s new file mode 100644 index 0000000000..6b5e2b0380 --- /dev/null +++ b/vendor/github.com/ebitengine/purego/zcallback_s390x.s @@ -0,0 +1,4015 @@ +// 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) diff --git a/vendor/github.com/moby/go-archive/archive.go b/vendor/github.com/moby/go-archive/archive.go index 7a105aef18..8dce2e6e2a 100644 --- a/vendor/github.com/moby/go-archive/archive.go +++ b/vendor/github.com/moby/go-archive/archive.go @@ -36,10 +36,6 @@ import ( const ImpliedDirectoryMode = 0o755 type ( - // Compression is the state represents if compressed or not. - // - // Deprecated: use [compression.Compression]. - Compression = compression.Compression // WhiteoutFormat is the format of whiteouts unpacked WhiteoutFormat int @@ -95,14 +91,6 @@ func NewDefaultArchiver() *Archiver { // in order for the test to pass. type breakoutError error -const ( - Uncompressed = compression.None // Deprecated: use [compression.None]. - Bzip2 = compression.Bzip2 // Deprecated: use [compression.Bzip2]. - Gzip = compression.Gzip // Deprecated: use [compression.Gzip]. - Xz = compression.Xz // Deprecated: use [compression.Xz]. - Zstd = compression.Zstd // Deprecated: use [compression.Zstd]. -) - const ( AUFSWhiteoutFormat WhiteoutFormat = 0 // AUFSWhiteoutFormat is the default format for whiteouts OverlayWhiteoutFormat WhiteoutFormat = 1 // OverlayWhiteoutFormat formats whiteout according to the overlay standard. @@ -126,27 +114,6 @@ func IsArchivePath(path string) bool { return err == nil } -// DetectCompression detects the compression algorithm of the source. -// -// Deprecated: use [compression.Detect]. -func DetectCompression(source []byte) compression.Compression { - return compression.Detect(source) -} - -// DecompressStream decompresses the archive and returns a ReaderCloser with the decompressed archive. -// -// Deprecated: use [compression.DecompressStream]. -func DecompressStream(archive io.Reader) (io.ReadCloser, error) { - return compression.DecompressStream(archive) -} - -// CompressStream compresses the dest with specified compression algorithm. -// -// Deprecated: use [compression.CompressStream]. -func CompressStream(dest io.Writer, comp compression.Compression) (io.WriteCloser, error) { - return compression.CompressStream(dest, comp) -} - // TarModifierFunc is a function that can be passed to ReplaceFileTarWrapper to // modify the contents or header of an entry in the archive. If the file already // exists in the archive the TarModifierFunc will be called with the Header and @@ -235,13 +202,6 @@ func ReplaceFileTarWrapper(inputTarStream io.ReadCloser, mods map[string]TarModi return pipeReader } -// FileInfoHeaderNoLookups creates a partially-populated tar.Header from fi. -// -// Deprecated: use [tarheader.FileInfoHeaderNoLookups]. -func FileInfoHeaderNoLookups(fi os.FileInfo, link string) (*tar.Header, error) { - return tarheader.FileInfoHeaderNoLookups(fi, link) -} - // FileInfoHeader creates a populated Header from fi. // // Compared to the archive/tar package, this function fills in less information diff --git a/vendor/github.com/moby/go-archive/xattr_supported_unix.go b/vendor/github.com/moby/go-archive/xattr_supported_unix.go index 4d8824158e..58a03e4a63 100644 --- a/vendor/github.com/moby/go-archive/xattr_supported_unix.go +++ b/vendor/github.com/moby/go-archive/xattr_supported_unix.go @@ -1,4 +1,4 @@ -//go:build !linux && !windows +//go:build darwin || freebsd || netbsd package archive diff --git a/vendor/github.com/moby/term/term_unix.go b/vendor/github.com/moby/term/term_unix.go index 2ec7706a16..579ce5530a 100644 --- a/vendor/github.com/moby/term/term_unix.go +++ b/vendor/github.com/moby/term/term_unix.go @@ -81,7 +81,7 @@ func setRawTerminal(fd uintptr) (*State, error) { return makeRaw(fd) } -func setRawTerminalOutput(fd uintptr) (*State, error) { +func setRawTerminalOutput(uintptr) (*State, error) { return nil, nil } diff --git a/vendor/github.com/power-devops/perfstat/config.go b/vendor/github.com/power-devops/perfstat/config.go index de7230d28c..a6df39c672 100644 --- a/vendor/github.com/power-devops/perfstat/config.go +++ b/vendor/github.com/power-devops/perfstat/config.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/cpustat.go b/vendor/github.com/power-devops/perfstat/cpustat.go index 902727fb8f..10f543fa4d 100644 --- a/vendor/github.com/power-devops/perfstat/cpustat.go +++ b/vendor/github.com/power-devops/perfstat/cpustat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat @@ -20,6 +21,13 @@ import ( "unsafe" ) +var old_cpu_total_stat *C.perfstat_cpu_total_t + +func init() { + old_cpu_total_stat = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t)) + C.perfstat_cpu_total(nil, old_cpu_total_stat, C.sizeof_perfstat_cpu_total_t, 1) +} + func CpuStat() ([]CPU, error) { var cpustat *C.perfstat_cpu_t var cpu C.perfstat_id_t @@ -96,3 +104,35 @@ func CpuUtilStat(intvl time.Duration) (*CPUUtil, error) { u := perfstatcpuutil2cpuutil(cpuutil) return &u, nil } + +func CpuUtilTotalStat() (*CPUUtil, error) { + var cpuutil *C.perfstat_cpu_util_t + var new_cpu_total_stat *C.perfstat_cpu_total_t + var data C.perfstat_rawdata_t + + new_cpu_total_stat = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t)) + cpuutil = (*C.perfstat_cpu_util_t)(C.malloc(C.sizeof_perfstat_cpu_util_t)) + defer C.free(unsafe.Pointer(cpuutil)) + + r := C.perfstat_cpu_total(nil, new_cpu_total_stat, C.sizeof_perfstat_cpu_total_t, 1) + if r <= 0 { + C.free(unsafe.Pointer(new_cpu_total_stat)) + return nil, fmt.Errorf("error perfstat_cpu_total()") + } + + data._type = C.UTIL_CPU_TOTAL + data.curstat = unsafe.Pointer(new_cpu_total_stat) + data.prevstat = unsafe.Pointer(old_cpu_total_stat) + data.sizeof_data = C.sizeof_perfstat_cpu_total_t + data.cur_elems = 1 + data.prev_elems = 1 + + r = C.perfstat_cpu_util(&data, cpuutil, C.sizeof_perfstat_cpu_util_t, 1) + C.free(unsafe.Pointer(old_cpu_total_stat)) + old_cpu_total_stat = new_cpu_total_stat + if r <= 0 { + return nil, fmt.Errorf("error perfstat_cpu_util()") + } + u := perfstatcpuutil2cpuutil(cpuutil) + return &u, nil +} diff --git a/vendor/github.com/power-devops/perfstat/diskstat.go b/vendor/github.com/power-devops/perfstat/diskstat.go index fc70dfaa4e..06763b4bc9 100644 --- a/vendor/github.com/power-devops/perfstat/diskstat.go +++ b/vendor/github.com/power-devops/perfstat/diskstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/doc.go b/vendor/github.com/power-devops/perfstat/doc.go index 85eaf3e7ed..9730a61c2c 100644 --- a/vendor/github.com/power-devops/perfstat/doc.go +++ b/vendor/github.com/power-devops/perfstat/doc.go @@ -1,3 +1,4 @@ +//go:build !aix // +build !aix // Copyright 2020 Power-Devops.com. All rights reserved. @@ -36,24 +37,24 @@ func DisableLVMStat() {} // CpuStat() returns array of CPU structures with information about // logical CPUs on the system. // IBM documentation: -// * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_int_cpu.html -// * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu.html +// - https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_int_cpu.html +// - https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu.html func CpuStat() ([]CPU, error) { return nil, fmt.Errorf("not implemented") } // CpuTotalStat() returns general information about CPUs on the system. // IBM documentation: -// * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_glob_cpu.html -// * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cputot.html +// - https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_glob_cpu.html +// - https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cputot.html func CpuTotalStat() (*CPUTotal, error) { return nil, fmt.Errorf("not implemented") } // CpuUtilStat() calculates CPU utilization. // IBM documentation: -// * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_cpu_util.html -// * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu_util.html +// - https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_cpu_util.html +// - https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu_util.html func CpuUtilStat(intvl time.Duration) (*CPUUtil, error) { return nil, fmt.Errorf("not implemented") } diff --git a/vendor/github.com/power-devops/perfstat/fsstat.go b/vendor/github.com/power-devops/perfstat/fsstat.go index 27f4c06c15..d3913197ac 100644 --- a/vendor/github.com/power-devops/perfstat/fsstat.go +++ b/vendor/github.com/power-devops/perfstat/fsstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/helpers.go b/vendor/github.com/power-devops/perfstat/helpers.go index e8d6997665..d5268ab53a 100644 --- a/vendor/github.com/power-devops/perfstat/helpers.go +++ b/vendor/github.com/power-devops/perfstat/helpers.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat @@ -7,6 +8,7 @@ package perfstat #include #include +#include #include "c_helpers.h" */ @@ -754,7 +756,7 @@ func fsinfo2filesystem(n *C.struct_fsinfo) FileSystem { i.Device = C.GoString(n.devname) i.MountPoint = C.GoString(n.fsname) i.FSType = int(n.fstype) - i.Flags = int(n.flags) + i.Flags = uint(n.flags) i.TotalBlocks = int64(n.totalblks) i.FreeBlocks = int64(n.freeblks) i.TotalInodes = int64(n.totalinodes) @@ -762,3 +764,56 @@ func fsinfo2filesystem(n *C.struct_fsinfo) FileSystem { return i } + +func lparinfo2partinfo(n C.lpar_info_format2_t) PartitionInfo { + var i PartitionInfo + + i.Version = int(n.version) + i.OnlineMemory = uint64(n.online_memory) + i.TotalDispatchTime = uint64(n.tot_dispatch_time) + i.PoolIdleTime = uint64(n.pool_idle_time) + i.DispatchLatency = uint64(n.dispatch_latency) + i.LparFlags = uint(n.lpar_flags) + i.PCpusInSys = uint(n.pcpus_in_sys) + i.OnlineVCpus = uint(n.online_vcpus) + i.OnlineLCpus = uint(n.online_lcpus) + i.PCpusInPool = uint(n.pcpus_in_pool) + i.UnallocCapacity = uint(n.unalloc_capacity) + i.EntitledCapacity = uint(n.entitled_capacity) + i.VariableWeight = uint(n.variable_weight) + i.UnallocWeight = uint(n.unalloc_weight) + i.MinReqVCpuCapacity = uint(n.min_req_vcpu_capacity) + i.GroupId = uint8(n.group_id) + i.PoolId = uint8(n.pool_id) + i.ShCpusInSys = uint(n.shcpus_in_sys) + i.MaxPoolCapacity = uint(n.max_pool_capacity) + i.EntitledPoolCapacity = uint(n.entitled_pool_capacity) + i.PoolMaxTime = uint64(n.pool_max_time) + i.PoolBusyTime = uint64(n.pool_busy_time) + i.PoolScaledBusyTime = uint64(n.pool_scaled_busy_time) + i.ShCpuTotalTime = uint64(n.shcpu_tot_time) + i.ShCpuBusyTime = uint64(n.shcpu_busy_time) + i.ShCpuScaledBusyTime = uint64(n.shcpu_scaled_busy_time) + i.EntMemCapacity = uint64(n.ent_mem_capacity) + i.PhysMem = uint64(n.phys_mem) + i.VrmPoolPhysMem = uint64(n.vrm_pool_physmem) + i.HypPageSize = uint(n.hyp_pagesize) + i.VrmPoolId = int(n.vrm_pool_id) + i.VrmGroupId = int(n.vrm_group_id) + i.VarMemWeight = int(n.var_mem_weight) + i.UnallocVarMemWeight = int(n.unalloc_var_mem_weight) + i.UnallocEntMemCapacity = uint64(n.unalloc_ent_mem_capacity) + i.TrueOnlineMemory = uint64(n.true_online_memory) + i.AmeOnlineMemory = uint64(n.ame_online_memory) + i.AmeType = uint8(n.ame_type) + i.SpecExecMode = uint8(n.spec_exec_mode) + i.AmeFactor = uint(n.ame_factor) + i.EmPartMajorCode = uint(n.em_part_major_code) + i.EmPartMinorCode = uint(n.em_part_minor_code) + i.BytesCoalesced = uint64(n.bytes_coalesced) + i.BytesCoalescedMemPool = uint64(n.bytes_coalesced_mempool) + i.PurrCoalescing = uint64(n.purr_coalescing) + i.SpurrCoalescing = uint64(n.spurr_coalescing) + + return i +} diff --git a/vendor/github.com/power-devops/perfstat/lparstat.go b/vendor/github.com/power-devops/perfstat/lparstat.go index 0ce35e3c56..470a1af2f9 100644 --- a/vendor/github.com/power-devops/perfstat/lparstat.go +++ b/vendor/github.com/power-devops/perfstat/lparstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat @@ -6,11 +7,13 @@ package perfstat #cgo LDFLAGS: -lperfstat #include +#include */ import "C" import ( "fmt" + "unsafe" ) func PartitionStat() (*PartitionConfig, error) { @@ -24,3 +27,14 @@ func PartitionStat() (*PartitionConfig, error) { return &p, nil } + +func LparInfo() (*PartitionInfo, error) { + var pinfo C.lpar_info_format2_t + + rc := C.lpar_get_info(C.LPAR_INFO_FORMAT2, unsafe.Pointer(&pinfo), C.sizeof_lpar_info_format2_t) + if rc != 0 { + return nil, fmt.Errorf("lpar_get_info() error") + } + p := lparinfo2partinfo(pinfo) + return &p, nil +} diff --git a/vendor/github.com/power-devops/perfstat/lvmstat.go b/vendor/github.com/power-devops/perfstat/lvmstat.go index eb2064c804..2ce99086ad 100644 --- a/vendor/github.com/power-devops/perfstat/lvmstat.go +++ b/vendor/github.com/power-devops/perfstat/lvmstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/memstat.go b/vendor/github.com/power-devops/perfstat/memstat.go index d211a73aac..52133f0a84 100644 --- a/vendor/github.com/power-devops/perfstat/memstat.go +++ b/vendor/github.com/power-devops/perfstat/memstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/netstat.go b/vendor/github.com/power-devops/perfstat/netstat.go index 4070da211b..847d2946ee 100644 --- a/vendor/github.com/power-devops/perfstat/netstat.go +++ b/vendor/github.com/power-devops/perfstat/netstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/procstat.go b/vendor/github.com/power-devops/perfstat/procstat.go index ecafebd8db..957ec2b33a 100644 --- a/vendor/github.com/power-devops/perfstat/procstat.go +++ b/vendor/github.com/power-devops/perfstat/procstat.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/sysconf.go b/vendor/github.com/power-devops/perfstat/sysconf.go index c7454d03d4..b557da0dea 100644 --- a/vendor/github.com/power-devops/perfstat/sysconf.go +++ b/vendor/github.com/power-devops/perfstat/sysconf.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/power-devops/perfstat/systemcfg.go b/vendor/github.com/power-devops/perfstat/systemcfg.go index 6287eb46ab..b7c7b72592 100644 --- a/vendor/github.com/power-devops/perfstat/systemcfg.go +++ b/vendor/github.com/power-devops/perfstat/systemcfg.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat @@ -70,6 +71,7 @@ const ( SC_TM_VER = 59 /* Transaction Memory version, 0 - not capable */ SC_NX_CAP = 60 /* NX GZIP capable */ SC_PKS_STATE = 61 /* Platform KeyStore */ + SC_MMA_VER = 62 ) /* kernel attributes */ @@ -119,6 +121,7 @@ const ( IMPL_POWER7 = 0x8000 /* 7 class CPU */ IMPL_POWER8 = 0x10000 /* 8 class CPU */ IMPL_POWER9 = 0x20000 /* 9 class CPU */ + IMPL_POWER10 = 0x20000 /* 10 class CPU */ ) // Values for implementation field for IA64 Architectures @@ -151,11 +154,13 @@ const ( PV_7 = 0x200000 /* Power PC 7 */ PV_8 = 0x300000 /* Power PC 8 */ PV_9 = 0x400000 /* Power PC 9 */ + PV_10 = 0x500000 /* Power PC 10 */ PV_5_Compat = 0x0F8000 /* Power PC 5 */ PV_6_Compat = 0x108000 /* Power PC 6 */ PV_7_Compat = 0x208000 /* Power PC 7 */ PV_8_Compat = 0x308000 /* Power PC 8 */ PV_9_Compat = 0x408000 /* Power PC 9 */ + PV_10_Compat = 0x508000 /* Power PC 10 */ PV_RESERVED_2 = 0x0A0000 /* source compatability */ PV_RESERVED_3 = 0x0B0000 /* source compatability */ PV_RS2 = 0x040000 /* Power RS2 */ @@ -181,19 +186,21 @@ const ( // Macros for identifying physical processor const ( - PPI4_1 = 0x35 - PPI4_2 = 0x38 - PPI4_3 = 0x39 - PPI4_4 = 0x3C - PPI4_5 = 0x44 - PPI5_1 = 0x3A - PPI5_2 = 0x3B - PPI6_1 = 0x3E - PPI7_1 = 0x3F - PPI7_2 = 0x4A - PPI8_1 = 0x4B - PPI8_2 = 0x4D - PPI9 = 0x4E + PPI4_1 = 0x35 + PPI4_2 = 0x38 + PPI4_3 = 0x39 + PPI4_4 = 0x3C + PPI4_5 = 0x44 + PPI5_1 = 0x3A + PPI5_2 = 0x3B + PPI6_1 = 0x3E + PPI7_1 = 0x3F + PPI7_2 = 0x4A + PPI8_1 = 0x4B + PPI8_2 = 0x4D + PPI9 = 0x4E + PPI9_1 = 0x4E + PPI10_1 = 0x80 ) // Macros for kernel attributes @@ -291,14 +298,32 @@ func GetCPUImplementation() string { return "POWER8" case impl&IMPL_POWER9 != 0: return "POWER9" + case impl&IMPL_POWER10 != 0: + return "Power10" default: return "Unknown" } } +func POWER10OrNewer() bool { + impl := unix.Getsystemcfg(SC_IMPL) + if impl&IMPL_POWER10 != 0 { + return true + } + return false +} + +func POWER10() bool { + impl := unix.Getsystemcfg(SC_IMPL) + if impl&IMPL_POWER10 != 0 { + return true + } + return false +} + func POWER9OrNewer() bool { impl := unix.Getsystemcfg(SC_IMPL) - if impl&IMPL_POWER9 != 0 { + if impl&IMPL_POWER10 != 0 || impl&IMPL_POWER9 != 0 { return true } return false @@ -314,7 +339,7 @@ func POWER9() bool { func POWER8OrNewer() bool { impl := unix.Getsystemcfg(SC_IMPL) - if impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 { + if impl&IMPL_POWER10 != 0 || impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 { return true } return false @@ -330,7 +355,7 @@ func POWER8() bool { func POWER7OrNewer() bool { impl := unix.Getsystemcfg(SC_IMPL) - if impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 || impl&IMPL_POWER7 != 0 { + if impl&IMPL_POWER10 != 0 || impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 || impl&IMPL_POWER7 != 0 { return true } return false @@ -419,6 +444,8 @@ func PksEnabled() bool { func CPUMode() string { impl := unix.Getsystemcfg(SC_VERS) switch impl { + case PV_10, PV_10_Compat: + return "Power10" case PV_9, PV_9_Compat: return "POWER9" case PV_8, PV_8_Compat: diff --git a/vendor/github.com/power-devops/perfstat/types_disk.go b/vendor/github.com/power-devops/perfstat/types_disk.go index ca1493d872..50e323dbe0 100644 --- a/vendor/github.com/power-devops/perfstat/types_disk.go +++ b/vendor/github.com/power-devops/perfstat/types_disk.go @@ -29,8 +29,8 @@ type DiskTotal struct { // Disk Adapter Types const ( DA_SCSI = 0 /* 0 ==> SCSI, SAS, other legacy adapter types */ - DA_VSCSI /* 1 ==> Virtual SCSI/SAS Adapter */ - DA_FCA /* 2 ==> Fiber Channel Adapter */ + DA_VSCSI = 1 /* 1 ==> Virtual SCSI/SAS Adapter */ + DA_FCA = 2 /* 2 ==> Fiber Channel Adapter */ ) type DiskAdapter struct { diff --git a/vendor/github.com/power-devops/perfstat/types_fs.go b/vendor/github.com/power-devops/perfstat/types_fs.go index 0be048a384..b4b43ac61a 100644 --- a/vendor/github.com/power-devops/perfstat/types_fs.go +++ b/vendor/github.com/power-devops/perfstat/types_fs.go @@ -8,7 +8,7 @@ type FileSystem struct { Device string /* name of the mounted device */ MountPoint string /* where the device is mounted */ FSType int /* File system type, see the constants below */ - Flags int /* Flags of the file system */ + Flags uint /* Flags of the file system */ TotalBlocks int64 /* number of 512 bytes blocks in the filesystem */ FreeBlocks int64 /* number of free 512 bytes block in the filesystem */ TotalInodes int64 /* total number of inodes in the filesystem */ diff --git a/vendor/github.com/power-devops/perfstat/types_lpar.go b/vendor/github.com/power-devops/perfstat/types_lpar.go index 2d3c32fa8c..f95f8c300c 100644 --- a/vendor/github.com/power-devops/perfstat/types_lpar.go +++ b/vendor/github.com/power-devops/perfstat/types_lpar.go @@ -66,3 +66,64 @@ type PartitionConfig struct { TargetMemExpSize int64 /* Expanded Memory Size in MB */ SubProcessorMode int32 /* Split core mode, its value can be 0,1,2 or 4. 0 for unsupported, 1 for capable but not enabled, 2 or 4 for enabled*/ } + +const ( + AME_TYPE_V1 = 0x1 + AME_TYPE_V2 = 0x2 + LPAR_INFO_CAPPED = 0x01 /* Parition Capped */ + LPAR_INFO_AUTH_PIC = 0x02 /* Authority granted for poolidle*/ + LPAR_INFO_SMT_ENABLED = 0x04 /* SMT Enabled */ + LPAR_INFO_WPAR_ACTIVE = 0x08 /* Process Running Within a WPAR */ + LPAR_INFO_EXTENDED = 0x10 /* Extended shared processor pool information */ + LPAR_INFO_AME_ENABLED = 0x20 /* Active Mem. Expansion (AME) enabled*/ + LPAR_INFO_SEM_ENABLED = 0x40 /* Speculative Execution Mode enabled */ +) + +type PartitionInfo struct { + Version int /* version for this structure */ + OnlineMemory uint64 /* MB of currently online memory */ + TotalDispatchTime uint64 /* Total lpar dispatch time in nsecs */ + PoolIdleTime uint64 /* Idle time of shared CPU pool nsecs*/ + DispatchLatency uint64 /* Max latency inbetween dispatches of this LPAR on physCPUS in nsecs */ + LparFlags uint /* LPAR flags */ + PCpusInSys uint /* # of active licensed physical CPUs in system */ + OnlineVCpus uint /* # of current online virtual CPUs */ + OnlineLCpus uint /* # of current online logical CPUs */ + PCpusInPool uint /* # physical CPUs in shared pool */ + UnallocCapacity uint /* Unallocated Capacity available in shared pool */ + EntitledCapacity uint /* Entitled Processor Capacity for this partition */ + VariableWeight uint /* Variable Processor Capacity Weight */ + UnallocWeight uint /* Unallocated Variable Weight available for this partition */ + MinReqVCpuCapacity uint /* OS minimum required virtual processor capacity. */ + GroupId uint8 /* ID of a LPAR group/aggregation */ + PoolId uint8 /* ID of a shared pool */ + ShCpusInSys uint /* # of physical processors allocated for shared processor use */ + MaxPoolCapacity uint /* Maximum processor capacity of partition's pool */ + EntitledPoolCapacity uint /* Entitled processor capacity of partition's pool */ + PoolMaxTime uint64 /* Summation of maximum time that could be consumed by the pool, in nanoseconds */ + PoolBusyTime uint64 /* Summation of busy time accumulated across all partitions in the pool, in nanoseconds */ + PoolScaledBusyTime uint64 /* Scaled summation of busy time accumulated across all partitions in the pool, in nanoseconds */ + ShCpuTotalTime uint64 /* Summation of total time across all physical processors allocated for shared processor use, in nanoseconds */ + ShCpuBusyTime uint64 /* Summation of busy time accumulated across all shared processor partitions, in nanoseconds */ + ShCpuScaledBusyTime uint64 /* Scaled summation of busy time accumulated across all shared processor partitions, in nanoseconds */ + EntMemCapacity uint64 /* Partition's current entitlement memory capacity setting */ + PhysMem uint64 /* Amount of physical memory, in bytes, currently backing the partition's logical memory */ + VrmPoolPhysMem uint64 /* Total amount of physical memory in the VRM pool */ + HypPageSize uint /* Page size hypervisor is using to virtualize partition's memory */ + VrmPoolId int /* ID of VRM pool */ + VrmGroupId int /* eWLM VRM group to which partition belongs */ + VarMemWeight int /* Partition's current variable memory capacity weighting setting */ + UnallocVarMemWeight int /* Amount of unallocated variable memory capacity weight available to LPAR's group */ + UnallocEntMemCapacity uint64 /* Amount of unallocated I/O memory entitlement available to LPAR's group */ + TrueOnlineMemory uint64 /* true MB of currently online memory */ + AmeOnlineMemory uint64 /* AME MB of currently online memory */ + AmeType uint8 + SpecExecMode uint8 /* Speculative Execution Mode */ + AmeFactor uint /* memory expansion factor for LPAR */ + EmPartMajorCode uint /* Major and minor codes for our */ + EmPartMinorCode uint /* current energy management mode */ + BytesCoalesced uint64 /* The number of bytes of the calling partition.s logical real memory coalesced because they contained duplicated data */ + BytesCoalescedMemPool uint64 /* If the calling partition is authorized to see pool wide statistics then the number of bytes of logical real memory coalesced because they contained duplicated data in the calling partition.s memory pool else set to zero.*/ + PurrCoalescing uint64 /* If the calling partition is authorized to see pool wide statistics then PURR cycles consumed to coalesce data else set to zero.*/ + SpurrCoalescing uint64 /* If the calling partition is authorized to see pool wide statistics then SPURR cycles consumed to coalesce data else set to zero.*/ +} diff --git a/vendor/github.com/power-devops/perfstat/uptime.go b/vendor/github.com/power-devops/perfstat/uptime.go index 2bd3e568d2..8608787479 100644 --- a/vendor/github.com/power-devops/perfstat/uptime.go +++ b/vendor/github.com/power-devops/perfstat/uptime.go @@ -1,3 +1,4 @@ +//go:build aix // +build aix package perfstat diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin.go index c61a470fba..d3b6dbc532 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin.go @@ -61,17 +61,17 @@ func Times(percpu bool) ([]TimesStat, error) { } func TimesWithContext(_ context.Context, percpu bool) ([]TimesStat, error) { - lib, err := common.NewLibrary(common.System) + sys, err := common.NewSystemLib() if err != nil { return nil, err } - defer lib.Close() + defer sys.Close() if percpu { - return perCPUTimes(lib) + return perCPUTimes(sys) } - return allCPUTimes(lib) + return allCPUTimes(sys) } // Returns only one CPUInfoStat on FreeBSD @@ -138,16 +138,12 @@ func CountsWithContext(_ context.Context, logical bool) (int, error) { return int(count), nil } -func perCPUTimes(machLib *common.Library) ([]TimesStat, error) { - machHostSelf := common.GetFunc[common.MachHostSelfFunc](machLib, common.MachHostSelfSym) - machTaskSelf := common.GetFunc[common.MachTaskSelfFunc](machLib, common.MachTaskSelfSym) - hostProcessorInfo := common.GetFunc[common.HostProcessorInfoFunc](machLib, common.HostProcessorInfoSym) - vmDeallocate := common.GetFunc[common.VMDeallocateFunc](machLib, common.VMDeallocateSym) - +func perCPUTimes(sys *common.SystemLib) ([]TimesStat, error) { var count, ncpu uint32 var cpuload *hostCpuLoadInfoData - status := hostProcessorInfo(machHostSelf(), processorCpuLoadInfo, &ncpu, uintptr(unsafe.Pointer(&cpuload)), &count) + status := sys.HostProcessorInfo(sys.MachHostSelf(), processorCpuLoadInfo, + &ncpu, uintptr(unsafe.Pointer(&cpuload)), &count) if status != common.KERN_SUCCESS { return nil, fmt.Errorf("host_processor_info error=%d", status) @@ -157,7 +153,7 @@ func perCPUTimes(machLib *common.Library) ([]TimesStat, error) { return nil, errors.New("host_processor_info returned nil cpuload") } - defer vmDeallocate(machTaskSelf(), uintptr(unsafe.Pointer(cpuload)), uintptr(ncpu)) + defer sys.VMDeallocate(sys.MachTaskSelf(), uintptr(unsafe.Pointer(cpuload)), uintptr(ncpu)) ret := []TimesStat{} loads := unsafe.Slice(cpuload, ncpu) @@ -170,21 +166,17 @@ func perCPUTimes(machLib *common.Library) ([]TimesStat, error) { Nice: float64(loads[i].cpuTicks[cpuStateNice]) / ClocksPerSec, Idle: float64(loads[i].cpuTicks[cpuStateIdle]) / ClocksPerSec, } - ret = append(ret, c) } return ret, nil } -func allCPUTimes(machLib *common.Library) ([]TimesStat, error) { - machHostSelf := common.GetFunc[common.MachHostSelfFunc](machLib, common.MachHostSelfSym) - hostStatistics := common.GetFunc[common.HostStatisticsFunc](machLib, common.HostStatisticsSym) - +func allCPUTimes(sys *common.SystemLib) ([]TimesStat, error) { var cpuload hostCpuLoadInfoData count := uint32(cpuStateMax) - status := hostStatistics(machHostSelf(), common.HOST_CPU_LOAD_INFO, + status := sys.HostStatistics(sys.MachHostSelf(), common.HOST_CPU_LOAD_INFO, uintptr(unsafe.Pointer(&cpuload)), &count) if status != common.KERN_SUCCESS { diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_arm64.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_arm64.go index 8e69d7cb13..2effcadf8d 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_arm64.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_arm64.go @@ -13,55 +13,43 @@ import ( // https://github.com/shoenig/go-m1cpu/blob/v0.1.6/cpu.go func getFrequency() (float64, error) { - ioKit, err := common.NewLibrary(common.IOKit) + iokit, err := common.NewIOKitLib() if err != nil { return 0, err } - defer ioKit.Close() + defer iokit.Close() - coreFoundation, err := common.NewLibrary(common.CoreFoundation) + corefoundation, err := common.NewCoreFoundationLib() if err != nil { return 0, err } - defer coreFoundation.Close() + defer corefoundation.Close() - ioServiceMatching := common.GetFunc[common.IOServiceMatchingFunc](ioKit, common.IOServiceMatchingSym) - ioServiceGetMatchingServices := common.GetFunc[common.IOServiceGetMatchingServicesFunc](ioKit, common.IOServiceGetMatchingServicesSym) - ioIteratorNext := common.GetFunc[common.IOIteratorNextFunc](ioKit, common.IOIteratorNextSym) - ioRegistryEntryGetName := common.GetFunc[common.IORegistryEntryGetNameFunc](ioKit, common.IORegistryEntryGetNameSym) - ioRegistryEntryCreateCFProperty := common.GetFunc[common.IORegistryEntryCreateCFPropertyFunc](ioKit, common.IORegistryEntryCreateCFPropertySym) - ioObjectRelease := common.GetFunc[common.IOObjectReleaseFunc](ioKit, common.IOObjectReleaseSym) - - cfStringCreateWithCString := common.GetFunc[common.CFStringCreateWithCStringFunc](coreFoundation, common.CFStringCreateWithCStringSym) - cfDataGetLength := common.GetFunc[common.CFDataGetLengthFunc](coreFoundation, common.CFDataGetLengthSym) - cfDataGetBytePtr := common.GetFunc[common.CFDataGetBytePtrFunc](coreFoundation, common.CFDataGetBytePtrSym) - cfRelease := common.GetFunc[common.CFReleaseFunc](coreFoundation, common.CFReleaseSym) - - matching := ioServiceMatching("AppleARMIODevice") + matching := iokit.IOServiceMatching("AppleARMIODevice") var iterator uint32 - if status := ioServiceGetMatchingServices(common.KIOMainPortDefault, uintptr(matching), &iterator); status != common.KERN_SUCCESS { + if status := iokit.IOServiceGetMatchingServices(common.KIOMainPortDefault, uintptr(matching), &iterator); status != common.KERN_SUCCESS { return 0.0, fmt.Errorf("IOServiceGetMatchingServices error=%d", status) } - defer ioObjectRelease(iterator) + defer iokit.IOObjectRelease(iterator) - pCorekey := cfStringCreateWithCString(common.KCFAllocatorDefault, "voltage-states5-sram", common.KCFStringEncodingUTF8) - defer cfRelease(uintptr(pCorekey)) + pCorekey := corefoundation.CFStringCreateWithCString(common.KCFAllocatorDefault, "voltage-states5-sram", common.KCFStringEncodingUTF8) + defer corefoundation.CFRelease(uintptr(pCorekey)) var pCoreHz uint32 for { - service := ioIteratorNext(iterator) + service := iokit.IOIteratorNext(iterator) if service <= 0 { break } buf := common.NewCStr(512) - ioRegistryEntryGetName(service, buf) + iokit.IORegistryEntryGetName(service, buf) if buf.GoString() == "pmgr" { - pCoreRef := ioRegistryEntryCreateCFProperty(service, uintptr(pCorekey), common.KCFAllocatorDefault, common.KNilOptions) - length := cfDataGetLength(uintptr(pCoreRef)) - data := cfDataGetBytePtr(uintptr(pCoreRef)) + pCoreRef := iokit.IORegistryEntryCreateCFProperty(service, uintptr(pCorekey), common.KCFAllocatorDefault, common.KNilOptions) + length := corefoundation.CFDataGetLength(uintptr(pCoreRef)) + data := corefoundation.CFDataGetBytePtr(uintptr(pCoreRef)) // composite uint32 from the byte array buf := unsafe.Slice((*byte)(data), length) @@ -69,11 +57,12 @@ func getFrequency() (float64, error) { // combine the bytes into a uint32 value b := buf[length-8 : length-4] pCoreHz = binary.LittleEndian.Uint32(b) - ioObjectRelease(service) + corefoundation.CFRelease(uintptr(pCoreRef)) + iokit.IOObjectRelease(service) break } - ioObjectRelease(service) + iokit.IOObjectRelease(service) } return float64(pCoreHz / 1_000_000), nil diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go index 8232c483cc..48f2804d94 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go @@ -128,7 +128,11 @@ func InfoWithContext(_ context.Context) ([]InfoStat, error) { func parseDmesgBoot(fileName string) (InfoStat, error) { c := InfoStat{} - lines, _ := common.ReadLines(fileName) + lines, err := common.ReadLines(fileName) + if err != nil { + return c, fmt.Errorf("could not read %s: %w", fileName, err) + } + for _, line := range lines { if matches := cpuEnd.FindStringSubmatch(line); matches != nil { break diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd.go index 107b574f88..3e0aeb26a4 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd.go @@ -126,7 +126,11 @@ func InfoWithContext(_ context.Context) ([]InfoStat, error) { func parseDmesgBoot(fileName string) (InfoStat, int, error) { c := InfoStat{} - lines, _ := common.ReadLines(fileName) + lines, err := common.ReadLines(fileName) + if err != nil { + return c, 0, fmt.Errorf("could not read %s: %w", fileName, err) + } + cpuNum := 1 // default cpu num is 1 for _, line := range lines { if matches := cpuEnd.FindStringSubmatch(line); matches != nil { diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_linux.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_linux.go index c6ec17e9c9..4072f19cf2 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_linux.go @@ -81,6 +81,13 @@ var armModelToModelName = map[uint64]string{ 0xd4c: "Cortex-X1C", 0xd4d: "Cortex-A715", 0xd4e: "Cortex-X3", + 0xd4f: "Neoverse-V2", + 0xd81: "Cortex-A720", + 0xd82: "Cortex-X4", + 0xd84: "Neoverse-V3", + 0xd85: "Cortex-X925", + 0xd87: "Cortex-A725", + 0xd8e: "Neoverse-N3", } func init() { @@ -98,6 +105,7 @@ func Times(percpu bool) ([]TimesStat, error) { func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { filename := common.HostProcWithContext(ctx, "stat") lines := []string{} + var err error if percpu { statlines, err := common.ReadLines(filename) if err != nil || len(statlines) < 2 { @@ -110,7 +118,10 @@ func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { lines = append(lines, line) } } else { - lines, _ = common.ReadLinesOffsetN(filename, 0, 1) + lines, err = common.ReadLinesOffsetN(filename, 0, 1) + if err != nil || len(lines) == 0 { + return []TimesStat{}, nil + } } ret := make([]TimesStat, 0, len(lines)) @@ -174,14 +185,17 @@ func Info() ([]InfoStat, error) { func InfoWithContext(ctx context.Context) ([]InfoStat, error) { filename := common.HostProcWithContext(ctx, "cpuinfo") - lines, _ := common.ReadLines(filename) + lines, err := common.ReadLines(filename) + if err != nil { + return nil, fmt.Errorf("could not read %s: %w", filename, err) + } var ret []InfoStat var processorName string c := InfoStat{CPU: -1, Cores: 1} for _, line := range lines { - fields := strings.Split(line, ":") + fields := strings.SplitN(line, ":", 2) if len(fields) < 2 { continue } @@ -207,6 +221,25 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { if strings.Contains(value, "S390") { processorName = "S390" } + case "mvendorid": + if !strings.HasPrefix(value, "0x") { + continue + } + + if v, err := strconv.ParseUint(value[2:], 16, 32); err == nil { + switch v { + case 0x31e: + c.VendorID = "Andes" + case 0x029: + c.VendorID = "Microchip" + case 0x127: + c.VendorID = "MIPS" + case 0x489: + c.VendorID = "SiFive" + case 0x5b7: + c.VendorID = "T-Head" + } + } case "CPU implementer": if v, err := strconv.ParseUint(value, 0, 8); err == nil { switch v { @@ -242,9 +275,9 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { c.VendorID = "Ampere" } } - case "cpu family": + case "cpu family", "marchid": c.Family = value - case "model", "CPU part": + case "model", "CPU part", "mimpid": c.Model = value // if CPU is arm based, model name is found via model number. refer to: arch/arm64/kernel/cpuinfo.c if c.VendorID == "ARM" { @@ -257,7 +290,7 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { } } } - case "Model Name", "model name", "cpu": + case "Model Name", "model name", "cpu", "uarch": c.ModelName = value if strings.Contains(value, "POWER") { c.Model = strings.Split(value, " ")[0] @@ -271,6 +304,10 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { val = strings.Split(value, ".")[0] } + if strings.EqualFold(val, "unknown") { + continue + } + t, err := strconv.ParseInt(val, 10, 64) if err != nil { return ret, err @@ -287,7 +324,7 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { return ret, err } c.CacheSize = int32(t) - case "physical id": + case "physical id", "hart": c.PhysicalID = value case "core id": c.CoreID = value @@ -295,6 +332,11 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { c.Flags = strings.FieldsFunc(value, func(r rune) bool { return r == ',' || r == ' ' }) + case "isa", "hart isa": + if len(c.Flags) != 0 || !strings.HasPrefix(value, "rv64") { + continue + } + c.Flags = riscvISAParse(value) case "microcode": c.Microcode = value } @@ -458,7 +500,7 @@ func CountsWithContext(ctx context.Context, logical bool) (int, error) { currentInfo = make(map[string]int) continue } - fields := strings.Split(line, ":") + fields := strings.SplitN(line, ":", 2) if len(fields) < 2 { continue } @@ -477,3 +519,13 @@ func CountsWithContext(ctx context.Context, logical bool) (int, error) { } return ret, nil } + +func riscvISAParse(s string) []string { + ext := strings.Split(s, "_") + if len(ext[0]) <= 4 { + return nil + } + // the base extensions must "rv64" prefix + base := strings.Split(ext[0][4:], "") + return append(base, ext[1:]...) +} diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go index a1dc14d21a..9e23edb6ea 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go @@ -36,7 +36,8 @@ func Times(percpu bool) ([]TimesStat, error) { return TimesWithContext(context.Background(), percpu) } -func TimesWithContext(_ context.Context, percpu bool) (ret []TimesStat, err error) { +func TimesWithContext(_ context.Context, percpu bool) ([]TimesStat, error) { + ret := make([]TimesStat, 0) if !percpu { mib := []int32{ctlKern, kernCpTime} buf, _, err := common.CallSyscall(mib) @@ -44,15 +45,15 @@ func TimesWithContext(_ context.Context, percpu bool) (ret []TimesStat, err erro return ret, err } times := (*cpuTimes)(unsafe.Pointer(&buf[0])) - stat := TimesStat{ + ret = append(ret, TimesStat{ CPU: "cpu-total", User: float64(times.User), Nice: float64(times.Nice), System: float64(times.Sys), Idle: float64(times.Idle), Irq: float64(times.Intr), - } - return []TimesStat{stat}, nil + }) + return ret, nil } ncpu, err := unix.SysctlUint32("hw.ncpu") diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go index 4ab02d03b8..9b37d296a8 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go @@ -54,7 +54,8 @@ func Times(percpu bool) ([]TimesStat, error) { return TimesWithContext(context.Background(), percpu) } -func TimesWithContext(_ context.Context, percpu bool) (ret []TimesStat, err error) { +func TimesWithContext(_ context.Context, percpu bool) ([]TimesStat, error) { + ret := make([]TimesStat, 0) if !percpu { mib := []int32{ctlKern, kernCpTime} buf, _, err := common.CallSyscall(mib) @@ -62,15 +63,15 @@ func TimesWithContext(_ context.Context, percpu bool) (ret []TimesStat, err erro return ret, err } times := (*cpuTimes)(unsafe.Pointer(&buf[0])) - stat := TimesStat{ + ret = append(ret, TimesStat{ CPU: "cpu-total", User: float64(times.User) / ClocksPerSec, Nice: float64(times.Nice) / ClocksPerSec, System: float64(times.Sys) / ClocksPerSec, Idle: float64(times.Idle) / ClocksPerSec, Irq: float64(times.Intr) / ClocksPerSec, - } - return []TimesStat{stat}, nil + }) + return ret, nil } ncpu, err := unix.SysctlUint32("hw.ncpu") diff --git a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go index 3f4416bfd7..a6000a3c50 100644 --- a/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go +++ b/vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go @@ -7,11 +7,15 @@ import ( "context" "errors" "fmt" + "math/bits" + "path/filepath" "strconv" + "strings" + "syscall" "unsafe" - "github.com/yusufpapurcu/wmi" "golang.org/x/sys/windows" + "golang.org/x/sys/windows/registry" "github.com/shirou/gopsutil/v4/internal/common" ) @@ -19,6 +23,8 @@ import ( var ( procGetNativeSystemInfo = common.Modkernel32.NewProc("GetNativeSystemInfo") procGetLogicalProcessorInformationEx = common.Modkernel32.NewProc("GetLogicalProcessorInformationEx") + procGetSystemFirmwareTable = common.Modkernel32.NewProc("GetSystemFirmwareTable") + procCallNtPowerInformation = common.ModPowrProf.NewProc("CallNtPowerInformation") ) type win32_Processor struct { //nolint:revive //FIXME @@ -46,6 +52,16 @@ type win32_SystemProcessorPerformanceInformation struct { //nolint:revive //FIXM InterruptCount uint64 // ULONG needs to be uint64 } +// https://learn.microsoft.com/en-us/windows/win32/power/processor-power-information-str +type processorPowerInformation struct { + number uint32 // http://download.microsoft.com/download/a/d/f/adf1347d-08dc-41a4-9084-623b1194d4b2/MoreThan64proc.docx + maxMhz uint32 + currentMhz uint32 + mhzLimit uint32 + maxIdleState uint32 + currentIdleState uint32 +} + const ( ClocksPerSec = 10000000.0 @@ -55,6 +71,30 @@ const ( // size of systemProcessorPerformanceInfoSize in memory win32_SystemProcessorPerformanceInfoSize = uint32(unsafe.Sizeof(win32_SystemProcessorPerformanceInformation{})) //nolint:revive //FIXME + + firmwareTableProviderSignatureRSMB = 0x52534d42 // "RSMB" https://gitlab.winehq.org/dreamer/wine/-/blame/wine-7.0-rc6/dlls/ntdll/unix/system.c#L230 + smBiosHeaderSize = 8 // SMBIOS header size + smbiosEndOfTable = 127 // Minimum length for processor structure + smbiosTypeProcessor = 4 // SMBIOS Type 4: Processor Information + smbiosProcessorMinLength = 0x18 // Minimum length for processor structure + + centralProcessorRegistryKey = `HARDWARE\DESCRIPTION\System\CentralProcessor` +) + +type relationship uint32 + +// https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getlogicalprocessorinformationex +const ( + relationProcessorCore = relationship(0) + relationProcessorPackage = relationship(3) +) + +const ( + kAffinitySize = unsafe.Sizeof(int(0)) + // https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/interrupt-affinity-and-priority + maxLogicalProcessorsPerGroup = uint32(unsafe.Sizeof(kAffinitySize * 8)) + // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-power_information_level + processorInformation = 11 ) // Times returns times stat per cpu and combined for all CPUs @@ -101,32 +141,101 @@ func Info() ([]InfoStat, error) { return InfoWithContext(context.Background()) } -func InfoWithContext(ctx context.Context) ([]InfoStat, error) { - var ret []InfoStat - var dst []win32_Processor - q := wmi.CreateQuery(&dst, "") - if err := common.WMIQueryWithContext(ctx, q, &dst); err != nil { - return ret, err +// this function iterates over each set bit in the package affinity mask, each bit represent a logical processor in a group (assuming you are iteriang over a package mask) +// the function is used also to compute the global logical processor number +// https://learn.microsoft.com/en-us/windows/win32/procthread/processor-groups +// see https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-group_affinity +// and https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-processor_relationship +// and https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-system_logical_processor_information_ex +func forEachSetBit64(mask uint64, fn func(bit int)) { + m := mask + for m != 0 { + b := bits.TrailingZeros64(m) + fn(b) + m &= m - 1 + } +} + +func getProcessorPowerInformation(ctx context.Context) ([]processorPowerInformation, error) { + numLP, countErr := CountsWithContext(ctx, true) + if countErr != nil { + return nil, fmt.Errorf("failed to get logical processor count: %w", countErr) + } + if numLP <= 0 { + return nil, fmt.Errorf("invalid logical processor count: %d", numLP) } - var procID string - for i, l := range dst { - procID = "" - if l.ProcessorID != nil { - procID = *l.ProcessorID - } + ppiSize := uintptr(numLP) * unsafe.Sizeof(processorPowerInformation{}) + buf := make([]byte, ppiSize) + ppi, _, err := procCallNtPowerInformation.Call( + uintptr(processorInformation), + 0, + 0, + uintptr(unsafe.Pointer(&buf[0])), + uintptr(ppiSize), + ) + if ppi != 0 { + return nil, fmt.Errorf("CallNtPowerInformation failed with code %d: %w", ppi, err) + } + ppis := unsafe.Slice((*processorPowerInformation)(unsafe.Pointer(&buf[0])), numLP) + return ppis, nil +} - cpu := InfoStat{ - CPU: int32(i), - Family: strconv.FormatUint(uint64(l.Family), 10), - VendorID: l.Manufacturer, - ModelName: l.Name, - Cores: int32(l.NumberOfLogicalProcessors), - PhysicalID: procID, - Mhz: float64(l.MaxClockSpeed), - Flags: []string{}, +func InfoWithContext(ctx context.Context) ([]InfoStat, error) { + var ret []InfoStat + processorPackages, err := getSystemLogicalProcessorInformationEx(relationProcessorPackage) + if err != nil { + return ret, fmt.Errorf("failed to get processor package information: %w", err) + } + + ppis, powerInformationErr := getProcessorPowerInformation(ctx) + if powerInformationErr != nil { + return ret, fmt.Errorf("failed to get processor power information: %w", powerInformationErr) + } + + family, processorId, smBIOSErr := getSMBIOSProcessorInfo() + if smBIOSErr != nil { + return ret, smBIOSErr + } + + for i, pkg := range processorPackages { + logicalCount := 0 + maxMhz := 0 + model := "" + vendorId := "" + // iterate over each set bit in the package affinity mask + for _, ga := range pkg.processor.groupMask { + g := int(ga.group) + forEachSetBit64(uint64(ga.mask), func(bit int) { + // the global logical processor label + globalLpl := g*int(maxLogicalProcessorsPerGroup) + bit + if globalLpl >= 0 && globalLpl < len(ppis) { + logicalCount++ + m := int(ppis[globalLpl].maxMhz) + if m > maxMhz { + maxMhz = m + } + } + + registryKeyPath := filepath.Join(centralProcessorRegistryKey, strconv.Itoa(globalLpl)) + key, err := registry.OpenKey(registry.LOCAL_MACHINE, registryKeyPath, registry.QUERY_VALUE|registry.READ) + if err == nil { + model = getRegistryStringValueIfUnset(key, "ProcessorNameString", model) + vendorId = getRegistryStringValueIfUnset(key, "VendorIdentifier", vendorId) + _ = key.Close() + } + }) } - ret = append(ret, cpu) + ret = append(ret, InfoStat{ + CPU: int32(i), + Family: strconv.FormatUint(uint64(family), 10), + VendorID: vendorId, + ModelName: model, + Cores: int32(logicalCount), + PhysicalID: processorId, + Mhz: float64(maxMhz), + Flags: []string{}, + }) } return ret, nil @@ -207,7 +316,7 @@ type systemInfo struct { } type groupAffinity struct { - mask uintptr // https://learn.microsoft.com/it-it/windows-hardware/drivers/kernel/interrupt-affinity-and-priority#about-kaffinity + mask uintptr // https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/interrupt-affinity-and-priority#about-kaffinity group uint16 reserved [3]uint16 } @@ -223,43 +332,128 @@ type processorRelationship struct { // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-system_logical_processor_information_ex type systemLogicalProcessorInformationEx struct { - Relationship uint32 - Size uint32 - Processor processorRelationship + relationship uint32 + size uint32 + processor processorRelationship } -func getPhysicalCoreCount() (int, error) { - var length uint32 - const relationAll = 0xffff - const relationProcessorCore = 0x0 +// getSMBIOSProcessorInfo reads the SMBIOS Type 4 (Processor Information) structure and returns the Processor Family and ProcessorId fields. +// If not found, returns 0 and an empty string. +func getSMBIOSProcessorInfo() (family uint8, processorId string, err error) { + // https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemfirmwaretable + size, _, err := procGetSystemFirmwareTable.Call( + uintptr(firmwareTableProviderSignatureRSMB), + 0, + 0, + 0, + ) + if size == 0 { + return 0, "", fmt.Errorf("failed to get SMBIOS table size: %w", err) + } + buf := make([]byte, size) + ret, _, err := procGetSystemFirmwareTable.Call( + uintptr(firmwareTableProviderSignatureRSMB), + 0, + uintptr(unsafe.Pointer(&buf[0])), + uintptr(size), + ) + if ret == 0 { + return 0, "", fmt.Errorf("failed to read SMBIOS table: %w", err) + } + // https://wiki.osdev.org/System_Management_BIOS + i := smBiosHeaderSize // skip SMBIOS header (first 8 bytes) + maxIterations := len(buf) * 2 + iterations := 0 + for i < len(buf) && iterations < maxIterations { + iterations++ + if i+4 > len(buf) { + break + } + typ := buf[i] + length := buf[i+1] + if typ == smbiosEndOfTable { + break + } + if typ == smbiosTypeProcessor && length >= smbiosProcessorMinLength && i+int(length) <= len(buf) { + // Ensure we have enough bytes for procIdBytes + if i+16 > len(buf) { + break + } + // Get the processor family from byte at offset 6 + family = buf[i+6] + // Extract processor ID bytes (8 bytes total) from offsets 8-15 + procIdBytes := buf[i+8 : i+16] + // Convert first 4 bytes to 32-bit EAX register value (little endian) + eax := uint32(procIdBytes[0]) | uint32(procIdBytes[1])<<8 | uint32(procIdBytes[2])<<16 | uint32(procIdBytes[3])<<24 + // Convert last 4 bytes to 32-bit EDX register value (little endian) + edx := uint32(procIdBytes[4]) | uint32(procIdBytes[5])<<8 | uint32(procIdBytes[6])<<16 | uint32(procIdBytes[7])<<24 + // Format processor ID as 16 character hex string (EDX+EAX) + procId := fmt.Sprintf("%08X%08X", edx, eax) + return family, procId, nil + } + // skip to next structure + j := i + int(length) + innerIterations := 0 + maxInner := len(buf) // failsafe for inner loop + for j+1 < len(buf) && innerIterations < maxInner { + innerIterations++ + if buf[j] == 0 && buf[j+1] == 0 { + j += 2 + break + } + j++ + } + if innerIterations >= maxInner { + break // malformed buffer, avoid infinite loop + } + i = j + } + return 0, "", fmt.Errorf("SMBIOS processor information not found: %w", syscall.ERROR_NOT_FOUND) +} +func getSystemLogicalProcessorInformationEx(relationship relationship) ([]systemLogicalProcessorInformationEx, error) { + var length uint32 // First call to determine the required buffer size - _, _, err := procGetLogicalProcessorInformationEx.Call(uintptr(relationAll), 0, uintptr(unsafe.Pointer(&length))) + _, _, err := procGetLogicalProcessorInformationEx.Call(uintptr(relationship), 0, uintptr(unsafe.Pointer(&length))) if err != nil && !errors.Is(err, windows.ERROR_INSUFFICIENT_BUFFER) { - return 0, fmt.Errorf("failed to get buffer size: %w", err) + return nil, fmt.Errorf("failed to get buffer size: %w", err) } // Allocate the buffer buffer := make([]byte, length) // Second call to retrieve the processor information - _, _, err = procGetLogicalProcessorInformationEx.Call(uintptr(relationAll), uintptr(unsafe.Pointer(&buffer[0])), uintptr(unsafe.Pointer(&length))) + _, _, err = procGetLogicalProcessorInformationEx.Call(uintptr(relationship), uintptr(unsafe.Pointer(&buffer[0])), uintptr(unsafe.Pointer(&length))) if err != nil && !errors.Is(err, windows.NTE_OP_OK) { - return 0, fmt.Errorf("failed to get logical processor information: %w", err) + return nil, fmt.Errorf("failed to get logical processor information: %w", err) } - // Iterate through the buffer to count physical cores + // Convert the byte slice into a slice of systemLogicalProcessorInformationEx structs offset := uintptr(0) - ncpus := 0 + var infos []systemLogicalProcessorInformationEx for offset < uintptr(length) { info := (*systemLogicalProcessorInformationEx)(unsafe.Pointer(uintptr(unsafe.Pointer(&buffer[0])) + offset)) - if info.Relationship == relationProcessorCore { - ncpus++ - } - offset += uintptr(info.Size) + infos = append(infos, *info) + offset += uintptr(info.size) } - return ncpus, nil + return infos, nil +} + +func getPhysicalCoreCount() (int, error) { + infos, err := getSystemLogicalProcessorInformationEx(relationProcessorCore) + return len(infos), err +} + +func getRegistryStringValueIfUnset(key registry.Key, keyName, value string) string { + if value != "" { + return value + } + val, _, err := key.GetStringValue(keyName) + if err == nil { + return strings.TrimSpace(val) + } + return "" } func CountsWithContext(_ context.Context, logical bool) (int, error) { @@ -270,12 +464,12 @@ func CountsWithContext(_ context.Context, logical bool) (int, error) { return int(ret), nil } - var systemInfo systemInfo - _, _, err := procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&systemInfo))) - if systemInfo.dwNumberOfProcessors == 0 { + var sInfo systemInfo + _, _, err := procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&sInfo))) + if sInfo.dwNumberOfProcessors == 0 { return 0, err } - return int(systemInfo.dwNumberOfProcessors), nil + return int(sInfo.dwNumberOfProcessors), nil } // Get physical core count https://github.com/giampaolo/psutil/blob/d01a9eaa35a8aadf6c519839e987a49d8be2d891/psutil/_psutil_windows.c#L499 diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/binary.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/binary.go deleted file mode 100644 index 11a4fd410f..0000000000 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/binary.go +++ /dev/null @@ -1,638 +0,0 @@ -// SPDX-License-Identifier: BSD-3-Clause -package common - -// 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. - -// Package binary implements simple translation between numbers and byte -// sequences and encoding and decoding of varints. -// -// Numbers are translated by reading and writing fixed-size values. -// A fixed-size value is either a fixed-size arithmetic -// type (int8, uint8, int16, float32, complex64, ...) -// or an array or struct containing only fixed-size values. -// -// The varint functions encode and decode single integer values using -// a variable-length encoding; smaller values require fewer bytes. -// For a specification, see -// http://code.google.com/apis/protocolbuffers/docs/encoding.html. -// -// This package favors simplicity over efficiency. Clients that require -// high-performance serialization, especially for large data structures, -// should look at more advanced solutions such as the encoding/gob -// package or protocol buffers. - -import ( - "errors" - "io" - "math" - "reflect" -) - -// A ByteOrder specifies how to convert byte sequences into -// 16-, 32-, or 64-bit unsigned integers. -type ByteOrder interface { - Uint16([]byte) uint16 - Uint32([]byte) uint32 - Uint64([]byte) uint64 - PutUint16([]byte, uint16) - PutUint32([]byte, uint32) - PutUint64([]byte, uint64) - String() string -} - -// LittleEndian is the little-endian implementation of ByteOrder. -var LittleEndian littleEndian - -// BigEndian is the big-endian implementation of ByteOrder. -var BigEndian bigEndian - -type littleEndian struct{} - -func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 } - -func (littleEndian) PutUint16(b []byte, v uint16) { - b[0] = byte(v) - b[1] = byte(v >> 8) -} - -func (littleEndian) Uint32(b []byte) uint32 { - return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 -} - -func (littleEndian) PutUint32(b []byte, v uint32) { - b[0] = byte(v) - b[1] = byte(v >> 8) - b[2] = byte(v >> 16) - b[3] = byte(v >> 24) -} - -func (littleEndian) Uint64(b []byte) uint64 { - return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | - uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 -} - -func (littleEndian) PutUint64(b []byte, v uint64) { - b[0] = byte(v) - b[1] = byte(v >> 8) - b[2] = byte(v >> 16) - b[3] = byte(v >> 24) - b[4] = byte(v >> 32) - b[5] = byte(v >> 40) - b[6] = byte(v >> 48) - b[7] = byte(v >> 56) -} - -func (littleEndian) String() string { return "LittleEndian" } - -func (littleEndian) GoString() string { return "binary.LittleEndian" } - -type bigEndian struct{} - -func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 } - -func (bigEndian) PutUint16(b []byte, v uint16) { - b[0] = byte(v >> 8) - b[1] = byte(v) -} - -func (bigEndian) Uint32(b []byte) uint32 { - return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24 -} - -func (bigEndian) PutUint32(b []byte, v uint32) { - b[0] = byte(v >> 24) - b[1] = byte(v >> 16) - b[2] = byte(v >> 8) - b[3] = byte(v) -} - -func (bigEndian) Uint64(b []byte) uint64 { - return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 | - uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56 -} - -func (bigEndian) PutUint64(b []byte, v uint64) { - b[0] = byte(v >> 56) - b[1] = byte(v >> 48) - b[2] = byte(v >> 40) - b[3] = byte(v >> 32) - b[4] = byte(v >> 24) - b[5] = byte(v >> 16) - b[6] = byte(v >> 8) - b[7] = byte(v) -} - -func (bigEndian) String() string { return "BigEndian" } - -func (bigEndian) GoString() string { return "binary.BigEndian" } - -// Read reads structured binary data from r into data. -// Data must be a pointer to a fixed-size value or a slice -// of fixed-size values. -// Bytes read from r are decoded using the specified byte order -// and written to successive fields of the data. -// When reading into structs, the field data for fields with -// blank (_) field names is skipped; i.e., blank field names -// may be used for padding. -// When reading into a struct, all non-blank fields must be exported. -func Read(r io.Reader, order ByteOrder, data any) error { - // Fast path for basic types and slices. - if n := intDataSize(data); n != 0 { - var b [8]byte - var bs []byte - if n > len(b) { - bs = make([]byte, n) - } else { - bs = b[:n] - } - if _, err := io.ReadFull(r, bs); err != nil { - return err - } - switch data := data.(type) { - case *int8: - *data = int8(b[0]) - case *uint8: - *data = b[0] - case *int16: - *data = int16(order.Uint16(bs)) - case *uint16: - *data = order.Uint16(bs) - case *int32: - *data = int32(order.Uint32(bs)) - case *uint32: - *data = order.Uint32(bs) - case *int64: - *data = int64(order.Uint64(bs)) - case *uint64: - *data = order.Uint64(bs) - case []int8: - for i, x := range bs { // Easier to loop over the input for 8-bit values. - data[i] = int8(x) - } - case []uint8: - copy(data, bs) - case []int16: - for i := range data { - data[i] = int16(order.Uint16(bs[2*i:])) - } - case []uint16: - for i := range data { - data[i] = order.Uint16(bs[2*i:]) - } - case []int32: - for i := range data { - data[i] = int32(order.Uint32(bs[4*i:])) - } - case []uint32: - for i := range data { - data[i] = order.Uint32(bs[4*i:]) - } - case []int64: - for i := range data { - data[i] = int64(order.Uint64(bs[8*i:])) - } - case []uint64: - for i := range data { - data[i] = order.Uint64(bs[8*i:]) - } - } - return nil - } - - // Fallback to reflect-based decoding. - v := reflect.ValueOf(data) - size := -1 - switch v.Kind() { - case reflect.Ptr: - v = v.Elem() - size = dataSize(v) - case reflect.Slice: - size = dataSize(v) - } - if size < 0 { - return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String()) - } - d := &decoder{order: order, buf: make([]byte, size)} - if _, err := io.ReadFull(r, d.buf); err != nil { - return err - } - d.value(v) - return nil -} - -// Write writes the binary representation of data into w. -// Data must be a fixed-size value or a slice of fixed-size -// values, or a pointer to such data. -// Bytes written to w are encoded using the specified byte order -// and read from successive fields of the data. -// When writing structs, zero values are written for fields -// with blank (_) field names. -func Write(w io.Writer, order ByteOrder, data any) error { - // Fast path for basic types and slices. - if n := intDataSize(data); n != 0 { - var b [8]byte - var bs []byte - if n > len(b) { - bs = make([]byte, n) - } else { - bs = b[:n] - } - switch v := data.(type) { - case *int8: - bs = b[:1] - b[0] = byte(*v) - case int8: - bs = b[:1] - b[0] = byte(v) - case []int8: - for i, x := range v { - bs[i] = byte(x) - } - case *uint8: - bs = b[:1] - b[0] = *v - case uint8: - bs = b[:1] - b[0] = byte(v) - case []uint8: - bs = v - case *int16: - bs = b[:2] - order.PutUint16(bs, uint16(*v)) - case int16: - bs = b[:2] - order.PutUint16(bs, uint16(v)) - case []int16: - for i, x := range v { - order.PutUint16(bs[2*i:], uint16(x)) - } - case *uint16: - bs = b[:2] - order.PutUint16(bs, *v) - case uint16: - bs = b[:2] - order.PutUint16(bs, v) - case []uint16: - for i, x := range v { - order.PutUint16(bs[2*i:], x) - } - case *int32: - bs = b[:4] - order.PutUint32(bs, uint32(*v)) - case int32: - bs = b[:4] - order.PutUint32(bs, uint32(v)) - case []int32: - for i, x := range v { - order.PutUint32(bs[4*i:], uint32(x)) - } - case *uint32: - bs = b[:4] - order.PutUint32(bs, *v) - case uint32: - bs = b[:4] - order.PutUint32(bs, v) - case []uint32: - for i, x := range v { - order.PutUint32(bs[4*i:], x) - } - case *int64: - bs = b[:8] - order.PutUint64(bs, uint64(*v)) - case int64: - bs = b[:8] - order.PutUint64(bs, uint64(v)) - case []int64: - for i, x := range v { - order.PutUint64(bs[8*i:], uint64(x)) - } - case *uint64: - bs = b[:8] - order.PutUint64(bs, *v) - case uint64: - bs = b[:8] - order.PutUint64(bs, v) - case []uint64: - for i, x := range v { - order.PutUint64(bs[8*i:], x) - } - } - _, err := w.Write(bs) - return err - } - - // Fallback to reflect-based encoding. - v := reflect.Indirect(reflect.ValueOf(data)) - size := dataSize(v) - if size < 0 { - return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String()) - } - buf := make([]byte, size) - e := &encoder{order: order, buf: buf} - e.value(v) - _, err := w.Write(buf) - return err -} - -// Size returns how many bytes Write would generate to encode the value v, which -// must be a fixed-size value or a slice of fixed-size values, or a pointer to such data. -// If v is neither of these, Size returns -1. -func Size(v any) int { - return dataSize(reflect.Indirect(reflect.ValueOf(v))) -} - -// dataSize returns the number of bytes the actual data represented by v occupies in memory. -// For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice -// it returns the length of the slice times the element size and does not count the memory -// occupied by the header. If the type of v is not acceptable, dataSize returns -1. -func dataSize(v reflect.Value) int { - if v.Kind() == reflect.Slice { - if s := sizeof(v.Type().Elem()); s >= 0 { - return s * v.Len() - } - return -1 - } - return sizeof(v.Type()) -} - -// sizeof returns the size >= 0 of variables for the given type or -1 if the type is not acceptable. -func sizeof(t reflect.Type) int { - switch t.Kind() { - case reflect.Array: - if s := sizeof(t.Elem()); s >= 0 { - return s * t.Len() - } - - case reflect.Struct: - sum := 0 - for i, n := 0, t.NumField(); i < n; i++ { - s := sizeof(t.Field(i).Type) - if s < 0 { - return -1 - } - sum += s - } - return sum - - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, - reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.Ptr: - return int(t.Size()) - } - - return -1 -} - -type coder struct { - order ByteOrder - buf []byte -} - -type ( - decoder coder - encoder coder -) - -func (d *decoder) uint8() uint8 { - x := d.buf[0] - d.buf = d.buf[1:] - return x -} - -func (e *encoder) uint8(x uint8) { - e.buf[0] = x - e.buf = e.buf[1:] -} - -func (d *decoder) uint16() uint16 { - x := d.order.Uint16(d.buf[0:2]) - d.buf = d.buf[2:] - return x -} - -func (e *encoder) uint16(x uint16) { - e.order.PutUint16(e.buf[0:2], x) - e.buf = e.buf[2:] -} - -func (d *decoder) uint32() uint32 { - x := d.order.Uint32(d.buf[0:4]) - d.buf = d.buf[4:] - return x -} - -func (e *encoder) uint32(x uint32) { - e.order.PutUint32(e.buf[0:4], x) - e.buf = e.buf[4:] -} - -func (d *decoder) uint64() uint64 { - x := d.order.Uint64(d.buf[0:8]) - d.buf = d.buf[8:] - return x -} - -func (e *encoder) uint64(x uint64) { - e.order.PutUint64(e.buf[0:8], x) - e.buf = e.buf[8:] -} - -func (d *decoder) int8() int8 { return int8(d.uint8()) } - -func (e *encoder) int8(x int8) { e.uint8(uint8(x)) } - -func (d *decoder) int16() int16 { return int16(d.uint16()) } - -func (e *encoder) int16(x int16) { e.uint16(uint16(x)) } - -func (d *decoder) int32() int32 { return int32(d.uint32()) } - -func (e *encoder) int32(x int32) { e.uint32(uint32(x)) } - -func (d *decoder) int64() int64 { return int64(d.uint64()) } - -func (e *encoder) int64(x int64) { e.uint64(uint64(x)) } - -func (d *decoder) value(v reflect.Value) { - switch v.Kind() { - case reflect.Array: - l := v.Len() - for i := 0; i < l; i++ { - d.value(v.Index(i)) - } - - case reflect.Struct: - t := v.Type() - l := v.NumField() - for i := 0; i < l; i++ { - // Note: Calling v.CanSet() below is an optimization. - // It would be sufficient to check the field name, - // but creating the StructField info for each field is - // costly (run "go test -bench=ReadStruct" and compare - // results when making changes to this code). - if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" { - d.value(v) - } else { - d.skip(v) - } - } - - case reflect.Slice: - l := v.Len() - for i := 0; i < l; i++ { - d.value(v.Index(i)) - } - - case reflect.Int8: - v.SetInt(int64(d.int8())) - case reflect.Int16: - v.SetInt(int64(d.int16())) - case reflect.Int32: - v.SetInt(int64(d.int32())) - case reflect.Int64: - v.SetInt(d.int64()) - - case reflect.Uint8: - v.SetUint(uint64(d.uint8())) - case reflect.Uint16: - v.SetUint(uint64(d.uint16())) - case reflect.Uint32: - v.SetUint(uint64(d.uint32())) - case reflect.Uint64: - v.SetUint(d.uint64()) - - case reflect.Float32: - v.SetFloat(float64(math.Float32frombits(d.uint32()))) - case reflect.Float64: - v.SetFloat(math.Float64frombits(d.uint64())) - - case reflect.Complex64: - v.SetComplex(complex( - float64(math.Float32frombits(d.uint32())), - float64(math.Float32frombits(d.uint32())), - )) - case reflect.Complex128: - v.SetComplex(complex( - math.Float64frombits(d.uint64()), - math.Float64frombits(d.uint64()), - )) - } -} - -func (e *encoder) value(v reflect.Value) { - switch v.Kind() { - case reflect.Array: - l := v.Len() - for i := 0; i < l; i++ { - e.value(v.Index(i)) - } - - case reflect.Struct: - t := v.Type() - l := v.NumField() - for i := 0; i < l; i++ { - // see comment for corresponding code in decoder.value() - if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" { - e.value(v) - } else { - e.skip(v) - } - } - - case reflect.Slice: - l := v.Len() - for i := 0; i < l; i++ { - e.value(v.Index(i)) - } - - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - switch v.Type().Kind() { - case reflect.Int8: - e.int8(int8(v.Int())) - case reflect.Int16: - e.int16(int16(v.Int())) - case reflect.Int32: - e.int32(int32(v.Int())) - case reflect.Int64: - e.int64(v.Int()) - } - - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - switch v.Type().Kind() { - case reflect.Uint8: - e.uint8(uint8(v.Uint())) - case reflect.Uint16: - e.uint16(uint16(v.Uint())) - case reflect.Uint32: - e.uint32(uint32(v.Uint())) - case reflect.Uint64: - e.uint64(v.Uint()) - } - - case reflect.Float32, reflect.Float64: - switch v.Type().Kind() { - case reflect.Float32: - e.uint32(math.Float32bits(float32(v.Float()))) - case reflect.Float64: - e.uint64(math.Float64bits(v.Float())) - } - - case reflect.Complex64, reflect.Complex128: - switch v.Type().Kind() { - case reflect.Complex64: - x := v.Complex() - e.uint32(math.Float32bits(float32(real(x)))) - e.uint32(math.Float32bits(float32(imag(x)))) - case reflect.Complex128: - x := v.Complex() - e.uint64(math.Float64bits(real(x))) - e.uint64(math.Float64bits(imag(x))) - } - } -} - -func (d *decoder) skip(v reflect.Value) { - d.buf = d.buf[dataSize(v):] -} - -func (e *encoder) skip(v reflect.Value) { - n := dataSize(v) - for i := range e.buf[0:n] { - e.buf[i] = 0 - } - e.buf = e.buf[n:] -} - -// intDataSize returns the size of the data required to represent the data when encoded. -// It returns zero if the type cannot be implemented by the fast path in Read or Write. -func intDataSize(data any) int { - switch data := data.(type) { - case int8, *int8, *uint8: - return 1 - case []int8: - return len(data) - case []uint8: - return len(data) - case int16, *int16, *uint16: - return 2 - case []int16: - return 2 * len(data) - case []uint16: - return 2 * len(data) - case int32, *int32, *uint32: - return 4 - case []int32: - return 4 * len(data) - case []uint32: - return 4 * len(data) - case int64, *int64, *uint64: - return 8 - case []int64: - return 8 * len(data) - case []uint64: - return 8 * len(data) - } - return 0 -} diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common.go index d48b41e511..f0d3c45466 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common.go @@ -7,6 +7,7 @@ package common // - linux (amd64, arm) // - freebsd (amd64) // - windows (amd64) +// - aix (ppc64) import ( "bufio" @@ -23,6 +24,7 @@ import ( "path/filepath" "reflect" "runtime" + "slices" "strconv" "strings" "time" @@ -49,7 +51,7 @@ func (i Invoke) Command(name string, arg ...string) ([]byte, error) { return i.CommandWithContext(ctx, name, arg...) } -func (i Invoke) CommandWithContext(ctx context.Context, name string, arg ...string) ([]byte, error) { +func (Invoke) CommandWithContext(ctx context.Context, name string, arg ...string) ([]byte, error) { cmd := exec.CommandContext(ctx, name, arg...) var buf bytes.Buffer @@ -290,22 +292,14 @@ func StringsHas(target []string, src string) bool { // StringsContains checks the src in any string of the target string slice func StringsContains(target []string, src string) bool { - for _, t := range target { - if strings.Contains(t, src) { - return true - } - } - return false + return slices.ContainsFunc(target, func(s string) bool { + return strings.Contains(s, src) + }) } // IntContains checks the src in any int of the target int slice. func IntContains(target []int, src int) bool { - for _, t := range target { - if src == t { - return true - } - } - return false + return slices.Contains(target, src) } // get struct attributes. @@ -340,7 +334,7 @@ func PathExists(filename string) bool { // PathExistsWithContents returns the filename exists and it is not empty func PathExistsWithContents(filename string) bool { - info, err := os.Stat(filename) + info, err := os.Stat(filename) //nolint:gosec // filename is constructed from system paths, not user input if err != nil { return false } @@ -449,7 +443,7 @@ func HostRootWithContext(ctx context.Context, combineWith ...string) string { } // getSysctrlEnv sets LC_ALL=C in a list of env vars for use when running -// sysctl commands (see DoSysctrl). +// sysctl commands. func getSysctrlEnv(env []string) []string { foundLC := false for i, line := range env { @@ -471,3 +465,11 @@ func Round(val float64, n int) float64 { // Multiply the value by pow10, round it, then divide it by pow10 return math.Round(val*pow10) / pow10 } + +func TimeSince(ts uint64) uint64 { + return uint64(time.Now().Unix()) - ts +} + +func TimeSinceMillis(ts uint64) uint64 { + return uint64(time.Now().UnixMilli()) - ts +} diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_aix.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_aix.go new file mode 100644 index 0000000000..5579c3bcc7 --- /dev/null +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_aix.go @@ -0,0 +1,131 @@ +// SPDX-License-Identifier: BSD-3-Clause +//go:build aix + +package common + +import ( + "context" + "errors" + "strconv" + "strings" +) + +func BootTimeWithContext(ctx context.Context, invoke Invoker) (btime uint64, err error) { + ut, err := UptimeWithContext(ctx, invoke) + if err != nil { + return 0, err + } + + if ut <= 0 { + return 0, errors.New("uptime was not set, so cannot calculate boot time from it") + } + + return TimeSince(ut), nil +} + +// Uses ps to get the elapsed time for PID 1 in DAYS-HOURS:MINUTES:SECONDS format. +// Examples of ps -o etimes -p 1 output: +// 124-01:40:39 (with days) +// 15:03:02 (without days, hours only) +// 01:02 (just-rebooted systems, minutes and seconds) +func UptimeWithContext(ctx context.Context, invoke Invoker) (uint64, error) { + out, err := invoke.CommandWithContext(ctx, "ps", "-o", "etimes", "-p", "1") + if err != nil { + return 0, err + } + + lines := strings.Split(strings.TrimSpace(string(out)), "\n") + if len(lines) < 2 { + return 0, errors.New("ps output has fewer than 2 rows") + } + + // Extract the etimes value from the second row, trimming whitespace + etimes := strings.TrimSpace(lines[1]) + return ParseUptime(etimes), nil +} + +// Parses etimes output from ps command into total seconds. +// Handles formats like: +// - "124-01:40:39" (DAYS-HOURS:MINUTES:SECONDS) +// - "15:03:02" (HOURS:MINUTES:SECONDS) +// - "01:02" (MINUTES:SECONDS, from just-rebooted systems) +func ParseUptime(etimes string) uint64 { + var days, hours, mins, secs uint64 + + // Check if days component is present (contains a dash) + if strings.Contains(etimes, "-") { + parts := strings.Split(etimes, "-") + if len(parts) != 2 { + return 0 + } + + var err error + days, err = strconv.ParseUint(parts[0], 10, 64) + if err != nil { + return 0 + } + + // Parse the HH:MM:SS portion (after days, must have 3 parts) + etimes = parts[1] + timeParts := strings.Split(etimes, ":") + if len(timeParts) != 3 { + return 0 + } + + var err2 error + hours, err2 = strconv.ParseUint(timeParts[0], 10, 64) + if err2 != nil { + return 0 + } + + mins, err2 = strconv.ParseUint(timeParts[1], 10, 64) + if err2 != nil { + return 0 + } + + secs, err2 = strconv.ParseUint(timeParts[2], 10, 64) + if err2 != nil { + return 0 + } + } else { + // Parse time portions (either HH:MM:SS or MM:SS) when no days present + timeParts := strings.Split(etimes, ":") + switch len(timeParts) { + case 3: + // HH:MM:SS format + var err error + hours, err = strconv.ParseUint(timeParts[0], 10, 64) + if err != nil { + return 0 + } + + mins, err = strconv.ParseUint(timeParts[1], 10, 64) + if err != nil { + return 0 + } + + secs, err = strconv.ParseUint(timeParts[2], 10, 64) + if err != nil { + return 0 + } + case 2: + // MM:SS format (just-rebooted systems) + var err error + mins, err = strconv.ParseUint(timeParts[0], 10, 64) + if err != nil { + return 0 + } + + secs, err = strconv.ParseUint(timeParts[1], 10, 64) + if err != nil { + return 0 + } + default: + return 0 + } + } + + // Convert to total seconds + totalSeconds := (days * 24 * 60 * 60) + (hours * 60 * 60) + (mins * 60) + secs + return totalSeconds +} diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go index c9d610540e..384b4c5a72 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go @@ -4,113 +4,320 @@ package common import ( - "context" "errors" "fmt" - "os" - "os/exec" - "strings" + "math" "unsafe" "github.com/ebitengine/purego" - "golang.org/x/sys/unix" ) -func DoSysctrlWithContext(ctx context.Context, mib string) ([]string, error) { - cmd := exec.CommandContext(ctx, "sysctl", "-n", mib) - cmd.Env = getSysctrlEnv(os.Environ()) - out, err := cmd.Output() - if err != nil { - return []string{}, err - } - v := strings.Replace(string(out), "{ ", "", 1) - v = strings.Replace(string(v), " }", "", 1) - values := strings.Fields(string(v)) - - return values, nil -} - -func CallSyscall(mib []int32) ([]byte, uint64, error) { - miblen := uint64(len(mib)) - - // get required buffer size - length := uint64(0) - _, _, err := unix.Syscall6( - 202, // unix.SYS___SYSCTL https://github.com/golang/sys/blob/76b94024e4b621e672466e8db3d7f084e7ddcad2/unix/zsysnum_darwin_amd64.go#L146 - uintptr(unsafe.Pointer(&mib[0])), - uintptr(miblen), - 0, - uintptr(unsafe.Pointer(&length)), - 0, - 0) - if err != 0 { - var b []byte - return b, length, err - } - if length == 0 { - var b []byte - return b, length, err - } - // get proc info itself - buf := make([]byte, length) - _, _, err = unix.Syscall6( - 202, // unix.SYS___SYSCTL https://github.com/golang/sys/blob/76b94024e4b621e672466e8db3d7f084e7ddcad2/unix/zsysnum_darwin_amd64.go#L146 - uintptr(unsafe.Pointer(&mib[0])), - uintptr(miblen), - uintptr(unsafe.Pointer(&buf[0])), - uintptr(unsafe.Pointer(&length)), - 0, - 0) - if err != 0 { - return buf, length, err - } - - return buf, length, nil -} - // Library represents a dynamic library loaded by purego. -type Library struct { - addr uintptr - path string - close func() +type library struct { + handle uintptr + fnMap map[string]any } // library paths const ( - IOKit = "/System/Library/Frameworks/IOKit.framework/IOKit" - CoreFoundation = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation" - System = "/usr/lib/libSystem.B.dylib" + IOKitLibPath = "/System/Library/Frameworks/IOKit.framework/IOKit" + CoreFoundationLibPath = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation" + SystemLibPath = "/usr/lib/libSystem.B.dylib" ) -func NewLibrary(path string) (*Library, error) { +func newLibrary(path string) (*library, error) { lib, err := purego.Dlopen(path, purego.RTLD_LAZY|purego.RTLD_GLOBAL) if err != nil { return nil, err } - closeFunc := func() { - purego.Dlclose(lib) - } - - return &Library{ - addr: lib, - path: path, - close: closeFunc, + return &library{ + handle: lib, + fnMap: make(map[string]any), }, nil } -func (lib *Library) Dlsym(symbol string) (uintptr, error) { - return purego.Dlsym(lib.addr, symbol) +func (lib *library) Dlsym(symbol string) (uintptr, error) { + return purego.Dlsym(lib.handle, symbol) } -func GetFunc[T any](lib *Library, symbol string) T { - var fptr T - purego.RegisterLibFunc(&fptr, lib.addr, symbol) - return fptr +func getFunc[T any](lib *library, symbol string) T { + var dlfun *dlFunc[T] + if f, ok := lib.fnMap[symbol].(*dlFunc[T]); ok { + dlfun = f + } else { + dlfun = newDlfunc[T](symbol) + dlfun.init(lib.handle) + lib.fnMap[symbol] = dlfun + } + return dlfun.fn } -func (lib *Library) Close() { - lib.close() +func (lib *library) Close() { + purego.Dlclose(lib.handle) +} + +type dlFunc[T any] struct { + sym string + fn T +} + +func (d *dlFunc[T]) init(handle uintptr) { + purego.RegisterLibFunc(&d.fn, handle, d.sym) +} + +func newDlfunc[T any](sym string) *dlFunc[T] { + return &dlFunc[T]{sym: sym} +} + +type CoreFoundationLib struct { + *library +} + +func NewCoreFoundationLib() (*CoreFoundationLib, error) { + library, err := newLibrary(CoreFoundationLibPath) + if err != nil { + return nil, err + } + return &CoreFoundationLib{library}, nil +} + +func (c *CoreFoundationLib) CFGetTypeID(cf uintptr) int64 { + fn := getFunc[CFGetTypeIDFunc](c.library, "CFGetTypeID") + return fn(cf) +} + +func (c *CoreFoundationLib) CFNumberCreate(allocator uintptr, theType int64, valuePtr uintptr) unsafe.Pointer { + fn := getFunc[CFNumberCreateFunc](c.library, "CFNumberCreate") + return fn(allocator, theType, valuePtr) +} + +func (c *CoreFoundationLib) CFNumberGetValue(num uintptr, theType int64, valuePtr uintptr) bool { + fn := getFunc[CFNumberGetValueFunc](c.library, "CFNumberGetValue") + return fn(num, theType, valuePtr) +} + +func (c *CoreFoundationLib) CFDictionaryCreate(allocator uintptr, keys, values *unsafe.Pointer, numValues int64, + keyCallBacks, valueCallBacks uintptr, +) unsafe.Pointer { + fn := getFunc[CFDictionaryCreateFunc](c.library, "CFDictionaryCreate") + return fn(allocator, keys, values, numValues, keyCallBacks, valueCallBacks) +} + +func (c *CoreFoundationLib) CFDictionaryAddValue(theDict, key, value uintptr) { + fn := getFunc[CFDictionaryAddValueFunc](c.library, "CFDictionaryAddValue") + fn(theDict, key, value) +} + +func (c *CoreFoundationLib) CFDictionaryGetValue(theDict, key uintptr) unsafe.Pointer { + fn := getFunc[CFDictionaryGetValueFunc](c.library, "CFDictionaryGetValue") + return fn(theDict, key) +} + +func (c *CoreFoundationLib) CFArrayGetCount(theArray uintptr) int64 { + fn := getFunc[CFArrayGetCountFunc](c.library, "CFArrayGetCount") + return fn(theArray) +} + +func (c *CoreFoundationLib) CFArrayGetValueAtIndex(theArray uintptr, index int64) unsafe.Pointer { + fn := getFunc[CFArrayGetValueAtIndexFunc](c.library, "CFArrayGetValueAtIndex") + return fn(theArray, index) +} + +func (c *CoreFoundationLib) CFStringCreateMutable(alloc uintptr, maxLength int64) unsafe.Pointer { + fn := getFunc[CFStringCreateMutableFunc](c.library, "CFStringCreateMutable") + return fn(alloc, maxLength) +} + +func (c *CoreFoundationLib) CFStringGetLength(theString uintptr) int64 { + fn := getFunc[CFStringGetLengthFunc](c.library, "CFStringGetLength") + return fn(theString) +} + +func (c *CoreFoundationLib) CFStringGetCString(theString uintptr, buffer CStr, bufferSize int64, encoding uint32) { + fn := getFunc[CFStringGetCStringFunc](c.library, "CFStringGetCString") + fn(theString, buffer, bufferSize, encoding) +} + +func (c *CoreFoundationLib) CFStringCreateWithCString(alloc uintptr, cStr string, encoding uint32) unsafe.Pointer { + fn := getFunc[CFStringCreateWithCStringFunc](c.library, "CFStringCreateWithCString") + return fn(alloc, cStr, encoding) +} + +func (c *CoreFoundationLib) CFDataGetLength(theData uintptr) int64 { + fn := getFunc[CFDataGetLengthFunc](c.library, "CFDataGetLength") + return fn(theData) +} + +func (c *CoreFoundationLib) CFDataGetBytePtr(theData uintptr) unsafe.Pointer { + fn := getFunc[CFDataGetBytePtrFunc](c.library, "CFDataGetBytePtr") + return fn(theData) +} + +func (c *CoreFoundationLib) CFRelease(cf uintptr) { + fn := getFunc[CFReleaseFunc](c.library, "CFRelease") + fn(cf) +} + +type IOKitLib struct { + *library +} + +func NewIOKitLib() (*IOKitLib, error) { + library, err := newLibrary(IOKitLibPath) + if err != nil { + return nil, err + } + return &IOKitLib{library}, nil +} + +func (l *IOKitLib) IOServiceGetMatchingService(mainPort uint32, matching uintptr) uint32 { + fn := getFunc[IOServiceGetMatchingServiceFunc](l.library, "IOServiceGetMatchingService") + return fn(mainPort, matching) +} + +func (l *IOKitLib) IOServiceGetMatchingServices(mainPort uint32, matching uintptr, existing *uint32) int32 { + fn := getFunc[IOServiceGetMatchingServicesFunc](l.library, "IOServiceGetMatchingServices") + return fn(mainPort, matching, existing) +} + +func (l *IOKitLib) IOServiceMatching(name string) unsafe.Pointer { + fn := getFunc[IOServiceMatchingFunc](l.library, "IOServiceMatching") + return fn(name) +} + +func (l *IOKitLib) IOServiceOpen(service, owningTask, connType uint32, connect *uint32) int32 { + fn := getFunc[IOServiceOpenFunc](l.library, "IOServiceOpen") + return fn(service, owningTask, connType, connect) +} + +func (l *IOKitLib) IOServiceClose(connect uint32) int32 { + fn := getFunc[IOServiceCloseFunc](l.library, "IOServiceClose") + return fn(connect) +} + +func (l *IOKitLib) IOIteratorNext(iterator uint32) uint32 { + fn := getFunc[IOIteratorNextFunc](l.library, "IOIteratorNext") + return fn(iterator) +} + +func (l *IOKitLib) IORegistryEntryGetName(entry uint32, name CStr) int32 { + fn := getFunc[IORegistryEntryGetNameFunc](l.library, "IORegistryEntryGetName") + return fn(entry, name) +} + +func (l *IOKitLib) IORegistryEntryGetParentEntry(entry uint32, plane string, parent *uint32) int32 { + fn := getFunc[IORegistryEntryGetParentEntryFunc](l.library, "IORegistryEntryGetParentEntry") + return fn(entry, plane, parent) +} + +func (l *IOKitLib) IORegistryEntryCreateCFProperty(entry uint32, key, allocator uintptr, options uint32) unsafe.Pointer { + fn := getFunc[IORegistryEntryCreateCFPropertyFunc](l.library, "IORegistryEntryCreateCFProperty") + return fn(entry, key, allocator, options) +} + +func (l *IOKitLib) IORegistryEntryCreateCFProperties(entry uint32, properties unsafe.Pointer, allocator uintptr, options uint32) int32 { + fn := getFunc[IORegistryEntryCreateCFPropertiesFunc](l.library, "IORegistryEntryCreateCFProperties") + return fn(entry, properties, allocator, options) +} + +func (l *IOKitLib) IOObjectConformsTo(object uint32, className string) bool { + fn := getFunc[IOObjectConformsToFunc](l.library, "IOObjectConformsTo") + return fn(object, className) +} + +func (l *IOKitLib) IOObjectRelease(object uint32) int32 { + fn := getFunc[IOObjectReleaseFunc](l.library, "IOObjectRelease") + return fn(object) +} + +func (l *IOKitLib) IOConnectCallStructMethod(connection, selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32 { + fn := getFunc[IOConnectCallStructMethodFunc](l.library, "IOConnectCallStructMethod") + return fn(connection, selector, inputStruct, inputStructCnt, outputStruct, outputStructCnt) +} + +func (l *IOKitLib) IOHIDEventSystemClientCreate(allocator uintptr) unsafe.Pointer { + fn := getFunc[IOHIDEventSystemClientCreateFunc](l.library, "IOHIDEventSystemClientCreate") + return fn(allocator) +} + +func (l *IOKitLib) IOHIDEventSystemClientSetMatching(client, match uintptr) int32 { + fn := getFunc[IOHIDEventSystemClientSetMatchingFunc](l.library, "IOHIDEventSystemClientSetMatching") + return fn(client, match) +} + +func (l *IOKitLib) IOHIDServiceClientCopyEvent(service uintptr, eventType int64, options int32, timeout int64) unsafe.Pointer { + fn := getFunc[IOHIDServiceClientCopyEventFunc](l.library, "IOHIDServiceClientCopyEvent") + return fn(service, eventType, options, timeout) +} + +func (l *IOKitLib) IOHIDServiceClientCopyProperty(service, property uintptr) unsafe.Pointer { + fn := getFunc[IOHIDServiceClientCopyPropertyFunc](l.library, "IOHIDServiceClientCopyProperty") + return fn(service, property) +} + +func (l *IOKitLib) IOHIDEventGetFloatValue(event uintptr, field int32) float64 { + fn := getFunc[IOHIDEventGetFloatValueFunc](l.library, "IOHIDEventGetFloatValue") + return fn(event, field) +} + +func (l *IOKitLib) IOHIDEventSystemClientCopyServices(client uintptr) unsafe.Pointer { + fn := getFunc[IOHIDEventSystemClientCopyServicesFunc](l.library, "IOHIDEventSystemClientCopyServices") + return fn(client) +} + +type SystemLib struct { + *library +} + +func NewSystemLib() (*SystemLib, error) { + library, err := newLibrary(SystemLibPath) + if err != nil { + return nil, err + } + return &SystemLib{library}, nil +} + +func (s *SystemLib) HostProcessorInfo(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo uintptr, + outProcessorInfoCnt *uint32, +) int32 { + fn := getFunc[HostProcessorInfoFunc](s.library, "host_processor_info") + return fn(host, flavor, outProcessorCount, outProcessorInfo, outProcessorInfoCnt) +} + +func (s *SystemLib) HostStatistics(host uint32, flavor int32, hostInfoOut uintptr, hostInfoOutCnt *uint32) int32 { + fn := getFunc[HostStatisticsFunc](s.library, "host_statistics") + return fn(host, flavor, hostInfoOut, hostInfoOutCnt) +} + +func (s *SystemLib) MachHostSelf() uint32 { + fn := getFunc[MachHostSelfFunc](s.library, "mach_host_self") + return fn() +} + +func (s *SystemLib) MachTaskSelf() uint32 { + fn := getFunc[MachTaskSelfFunc](s.library, "mach_task_self") + return fn() +} + +func (s *SystemLib) MachTimeBaseInfo(info uintptr) int32 { + fn := getFunc[MachTimeBaseInfoFunc](s.library, "mach_timebase_info") + return fn(info) +} + +func (s *SystemLib) VMDeallocate(targetTask uint32, vmAddress, vmSize uintptr) int32 { + fn := getFunc[VMDeallocateFunc](s.library, "vm_deallocate") + return fn(targetTask, vmAddress, vmSize) +} + +func (s *SystemLib) ProcPidPath(pid int32, buffer uintptr, bufferSize uint32) int32 { + fn := getFunc[ProcPidPathFunc](s.library, "proc_pidpath") + return fn(pid, buffer, bufferSize) +} + +func (s *SystemLib) ProcPidInfo(pid, flavor int32, arg uint64, buffer uintptr, bufferSize int32) int32 { + fn := getFunc[ProcPidInfoFunc](s.library, "proc_pidinfo") + return fn(pid, flavor, arg, buffer, bufferSize) } // status codes @@ -118,24 +325,24 @@ const ( KERN_SUCCESS = 0 ) -// IOKit functions and symbols. +// IOKit types and constants. type ( IOServiceGetMatchingServiceFunc func(mainPort uint32, matching uintptr) uint32 - IOServiceGetMatchingServicesFunc func(mainPort uint32, matching uintptr, existing *uint32) int + IOServiceGetMatchingServicesFunc func(mainPort uint32, matching uintptr, existing *uint32) int32 IOServiceMatchingFunc func(name string) unsafe.Pointer - IOServiceOpenFunc func(service, owningTask, connType uint32, connect *uint32) int - IOServiceCloseFunc func(connect uint32) int + IOServiceOpenFunc func(service, owningTask, connType uint32, connect *uint32) int32 + IOServiceCloseFunc func(connect uint32) int32 IOIteratorNextFunc func(iterator uint32) uint32 - IORegistryEntryGetNameFunc func(entry uint32, name CStr) int - IORegistryEntryGetParentEntryFunc func(entry uint32, plane string, parent *uint32) int + IORegistryEntryGetNameFunc func(entry uint32, name CStr) int32 + IORegistryEntryGetParentEntryFunc func(entry uint32, plane string, parent *uint32) int32 IORegistryEntryCreateCFPropertyFunc func(entry uint32, key, allocator uintptr, options uint32) unsafe.Pointer - IORegistryEntryCreateCFPropertiesFunc func(entry uint32, properties unsafe.Pointer, allocator uintptr, options uint32) int + IORegistryEntryCreateCFPropertiesFunc func(entry uint32, properties unsafe.Pointer, allocator uintptr, options uint32) int32 IOObjectConformsToFunc func(object uint32, className string) bool - IOObjectReleaseFunc func(object uint32) int - IOConnectCallStructMethodFunc func(connection, selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int + IOObjectReleaseFunc func(object uint32) int32 + IOConnectCallStructMethodFunc func(connection, selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32 IOHIDEventSystemClientCreateFunc func(allocator uintptr) unsafe.Pointer - IOHIDEventSystemClientSetMatchingFunc func(client, match uintptr) int + IOHIDEventSystemClientSetMatchingFunc func(client, match uintptr) int32 IOHIDServiceClientCopyEventFunc func(service uintptr, eventType int64, options int32, timeout int64) unsafe.Pointer IOHIDServiceClientCopyPropertyFunc func(service, property uintptr) unsafe.Pointer @@ -143,29 +350,6 @@ type ( IOHIDEventSystemClientCopyServicesFunc func(client uintptr) unsafe.Pointer ) -const ( - IOServiceGetMatchingServiceSym = "IOServiceGetMatchingService" - IOServiceGetMatchingServicesSym = "IOServiceGetMatchingServices" - IOServiceMatchingSym = "IOServiceMatching" - IOServiceOpenSym = "IOServiceOpen" - IOServiceCloseSym = "IOServiceClose" - IOIteratorNextSym = "IOIteratorNext" - IORegistryEntryGetNameSym = "IORegistryEntryGetName" - IORegistryEntryGetParentEntrySym = "IORegistryEntryGetParentEntry" - IORegistryEntryCreateCFPropertySym = "IORegistryEntryCreateCFProperty" - IORegistryEntryCreateCFPropertiesSym = "IORegistryEntryCreateCFProperties" - IOObjectConformsToSym = "IOObjectConformsTo" - IOObjectReleaseSym = "IOObjectRelease" - IOConnectCallStructMethodSym = "IOConnectCallStructMethod" - - IOHIDEventSystemClientCreateSym = "IOHIDEventSystemClientCreate" - IOHIDEventSystemClientSetMatchingSym = "IOHIDEventSystemClientSetMatching" - IOHIDServiceClientCopyEventSym = "IOHIDServiceClientCopyEvent" - IOHIDServiceClientCopyPropertySym = "IOHIDServiceClientCopyProperty" - IOHIDEventGetFloatValueSym = "IOHIDEventGetFloatValue" - IOHIDEventSystemClientCopyServicesSym = "IOHIDEventSystemClientCopyServices" -) - const ( KIOMainPortDefault = 0 @@ -179,52 +363,35 @@ const ( KIOServicePlane = "IOService" ) -// CoreFoundation functions and symbols. +// CoreFoundation types and constants. type ( - CFGetTypeIDFunc func(cf uintptr) int32 - CFNumberCreateFunc func(allocator uintptr, theType int32, valuePtr uintptr) unsafe.Pointer - CFNumberGetValueFunc func(num uintptr, theType int32, valuePtr uintptr) bool - CFDictionaryCreateFunc func(allocator uintptr, keys, values *unsafe.Pointer, numValues int32, + CFGetTypeIDFunc func(cf uintptr) int64 + CFNumberCreateFunc func(allocator uintptr, theType int64, valuePtr uintptr) unsafe.Pointer + CFNumberGetValueFunc func(num uintptr, theType int64, valuePtr uintptr) bool + CFDictionaryCreateFunc func(allocator uintptr, keys, values *unsafe.Pointer, numValues int64, keyCallBacks, valueCallBacks uintptr) unsafe.Pointer CFDictionaryAddValueFunc func(theDict, key, value uintptr) CFDictionaryGetValueFunc func(theDict, key uintptr) unsafe.Pointer - CFArrayGetCountFunc func(theArray uintptr) int32 - CFArrayGetValueAtIndexFunc func(theArray uintptr, index int32) unsafe.Pointer - CFStringCreateMutableFunc func(alloc uintptr, maxLength int32) unsafe.Pointer - CFStringGetLengthFunc func(theString uintptr) int32 - CFStringGetCStringFunc func(theString uintptr, buffer CStr, bufferSize int32, encoding uint32) + CFArrayGetCountFunc func(theArray uintptr) int64 + CFArrayGetValueAtIndexFunc func(theArray uintptr, index int64) unsafe.Pointer + CFStringCreateMutableFunc func(alloc uintptr, maxLength int64) unsafe.Pointer + CFStringGetLengthFunc func(theString uintptr) int64 + CFStringGetCStringFunc func(theString uintptr, buffer CStr, bufferSize int64, encoding uint32) CFStringCreateWithCStringFunc func(alloc uintptr, cStr string, encoding uint32) unsafe.Pointer - CFDataGetLengthFunc func(theData uintptr) int32 + CFDataGetLengthFunc func(theData uintptr) int64 CFDataGetBytePtrFunc func(theData uintptr) unsafe.Pointer CFReleaseFunc func(cf uintptr) ) -const ( - CFGetTypeIDSym = "CFGetTypeID" - CFNumberCreateSym = "CFNumberCreate" - CFNumberGetValueSym = "CFNumberGetValue" - CFDictionaryCreateSym = "CFDictionaryCreate" - CFDictionaryAddValueSym = "CFDictionaryAddValue" - CFDictionaryGetValueSym = "CFDictionaryGetValue" - CFArrayGetCountSym = "CFArrayGetCount" - CFArrayGetValueAtIndexSym = "CFArrayGetValueAtIndex" - CFStringCreateMutableSym = "CFStringCreateMutable" - CFStringGetLengthSym = "CFStringGetLength" - CFStringGetCStringSym = "CFStringGetCString" - CFStringCreateWithCStringSym = "CFStringCreateWithCString" - CFDataGetLengthSym = "CFDataGetLength" - CFDataGetBytePtrSym = "CFDataGetBytePtr" - CFReleaseSym = "CFRelease" -) - const ( KCFStringEncodingUTF8 = 0x08000100 KCFNumberSInt64Type = 4 KCFNumberIntType = 9 KCFAllocatorDefault = 0 + KCFNotFound = -1 ) -// Kernel functions and symbols. +// libSystem types and constants. type MachTimeBaseInfo struct { Numer uint32 Denom uint32 @@ -232,12 +399,12 @@ type MachTimeBaseInfo struct { type ( HostProcessorInfoFunc func(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo uintptr, - outProcessorInfoCnt *uint32) int - HostStatisticsFunc func(host uint32, flavor int32, hostInfoOut uintptr, hostInfoOutCnt *uint32) int + outProcessorInfoCnt *uint32) int32 + HostStatisticsFunc func(host uint32, flavor int32, hostInfoOut uintptr, hostInfoOutCnt *uint32) int32 MachHostSelfFunc func() uint32 MachTaskSelfFunc func() uint32 - MachTimeBaseInfoFunc func(info uintptr) int - VMDeallocateFunc func(targetTask uint32, vmAddress, vmSize uintptr) int + MachTimeBaseInfoFunc func(info uintptr) int32 + VMDeallocateFunc func(targetTask uint32, vmAddress, vmSize uintptr) int32 ) const ( @@ -250,17 +417,12 @@ const ( ) const ( - CTL_KERN = 1 - KERN_ARGMAX = 8 - KERN_PROCARGS2 = 49 - HOST_VM_INFO = 2 HOST_CPU_LOAD_INFO = 3 HOST_VM_INFO_COUNT = 0xf ) -// System functions and symbols. type ( ProcPidPathFunc func(pid int32, buffer uintptr, bufferSize uint32) int32 ProcPidInfoFunc func(pid, flavor int32, arg uint64, buffer uintptr, bufferSize int32) int32 @@ -274,6 +436,7 @@ const ( const ( MAXPATHLEN = 1024 + PROC_PIDLISTFDS = 1 PROC_PIDPATHINFO_MAXSIZE = 4 * MAXPATHLEN PROC_PIDTASKINFO = 4 PROC_PIDVNODEPATHINFO = 9 @@ -281,9 +444,8 @@ const ( // SMC represents a SMC instance. type SMC struct { - lib *Library - conn uint32 - callStruct IOConnectCallStructMethodFunc + lib *IOKitLib + conn uint32 } const ioServiceSMC = "AppleSMC" @@ -305,59 +467,50 @@ const ( KSMCKeyNotFound = 132 ) -func NewSMC(ioKit *Library) (*SMC, error) { - if ioKit.path != IOKit { - return nil, errors.New("library is not IOKit") +func NewSMC() (*SMC, error) { + iokit, err := NewIOKitLib() + if err != nil { + return nil, err } - ioServiceGetMatchingService := GetFunc[IOServiceGetMatchingServiceFunc](ioKit, IOServiceGetMatchingServiceSym) - ioServiceMatching := GetFunc[IOServiceMatchingFunc](ioKit, IOServiceMatchingSym) - ioServiceOpen := GetFunc[IOServiceOpenFunc](ioKit, IOServiceOpenSym) - ioObjectRelease := GetFunc[IOObjectReleaseFunc](ioKit, IOObjectReleaseSym) - machTaskSelf := GetFunc[MachTaskSelfFunc](ioKit, MachTaskSelfSym) - - ioConnectCallStructMethod := GetFunc[IOConnectCallStructMethodFunc](ioKit, IOConnectCallStructMethodSym) - - service := ioServiceGetMatchingService(0, uintptr(ioServiceMatching(ioServiceSMC))) + service := iokit.IOServiceGetMatchingService(0, uintptr(iokit.IOServiceMatching(ioServiceSMC))) if service == 0 { return nil, fmt.Errorf("ERROR: %s NOT FOUND", ioServiceSMC) } var conn uint32 - if result := ioServiceOpen(service, machTaskSelf(), 0, &conn); result != 0 { + machTaskSelf := getFunc[MachTaskSelfFunc](iokit.library, "mach_task_self") + if result := iokit.IOServiceOpen(service, machTaskSelf(), 0, &conn); result != 0 { return nil, errors.New("ERROR: IOServiceOpen failed") } - ioObjectRelease(service) + iokit.IOObjectRelease(service) return &SMC{ - lib: ioKit, - conn: conn, - callStruct: ioConnectCallStructMethod, + lib: iokit, + conn: conn, }, nil } -func (s *SMC) CallStruct(selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int { - return s.callStruct(s.conn, selector, inputStruct, inputStructCnt, outputStruct, outputStructCnt) +func (s *SMC) CallStruct(selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32 { + return s.lib.IOConnectCallStructMethod(s.conn, selector, inputStruct, inputStructCnt, outputStruct, outputStructCnt) } func (s *SMC) Close() error { - ioServiceClose := GetFunc[IOServiceCloseFunc](s.lib, IOServiceCloseSym) - - if result := ioServiceClose(s.conn); result != 0 { + if result := s.lib.IOServiceClose(s.conn); result != 0 { return errors.New("ERROR: IOServiceClose failed") } + s.lib.Close() return nil } type CStr []byte -func NewCStr(length int32) CStr { +func NewCStr(length int64) CStr { return make(CStr, length) } -func (s CStr) Length() int32 { - // Include null terminator to make CFStringGetCString properly functions - return int32(len(s)) + 1 +func (s CStr) Length() int64 { + return int64(len(s)) } func (s CStr) Ptr() *byte { @@ -398,3 +551,11 @@ func GoString(cStr *byte) string { } return string(unsafe.Slice(cStr, length)) } + +// https://github.com/apple-oss-distributions/CF/blob/dc54c6bb1c1e5e0b9486c1d26dd5bef110b20bf3/CFString.c#L463 +func GetCFStringBufLengthForUTF8(length int64) int64 { + if length > (math.MaxInt64 / 3) { + return KCFNotFound + } + return length*3 + 1 // includes null terminator +} diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_freebsd.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_freebsd.go index 53cdceeb6d..7a40a40c2b 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_freebsd.go @@ -5,9 +5,6 @@ package common import ( "fmt" - "os" - "os/exec" - "strings" "unsafe" "golang.org/x/sys/unix" @@ -28,20 +25,6 @@ func SysctlUint(mib string) (uint64, error) { return 0, fmt.Errorf("unexpected size: %s, %d", mib, len(buf)) } -func DoSysctrl(mib string) ([]string, error) { - cmd := exec.Command("sysctl", "-n", mib) - cmd.Env = getSysctrlEnv(os.Environ()) - out, err := cmd.Output() - if err != nil { - return []string{}, err - } - v := strings.Replace(string(out), "{ ", "", 1) - v = strings.Replace(string(v), " }", "", 1) - values := strings.Fields(string(v)) - - return values, nil -} - func CallSyscall(mib []int32) ([]byte, uint64, error) { mibptr := unsafe.Pointer(&mib[0]) miblen := uint64(len(mib)) diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_linux.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_linux.go index ffaae423b3..a2473f41dc 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_linux.go @@ -7,7 +7,6 @@ import ( "context" "errors" "os" - "os/exec" "path/filepath" "strconv" "strings" @@ -20,20 +19,6 @@ import ( // cachedBootTime must be accessed via atomic.Load/StoreUint64 var cachedBootTime uint64 -func DoSysctrl(mib string) ([]string, error) { - cmd := exec.Command("sysctl", "-n", mib) - cmd.Env = getSysctrlEnv(os.Environ()) - out, err := cmd.Output() - if err != nil { - return []string{}, err - } - v := strings.Replace(string(out), "{ ", "", 1) - v = strings.Replace(string(v), " }", "", 1) - values := strings.Fields(string(v)) - - return values, nil -} - func NumProcs() (uint64, error) { return NumProcsWithContext(context.Background()) } @@ -119,18 +104,18 @@ func BootTimeWithContext(ctx context.Context, enableCache bool) (uint64, error) } func handleBootTimeFileReadErr(err error) (uint64, error) { - if os.IsPermission(err) { - var info syscall.Sysinfo_t - err := syscall.Sysinfo(&info) - if err != nil { - return 0, err - } - - currentTime := time.Now().UnixNano() / int64(time.Second) - t := currentTime - int64(info.Uptime) - return uint64(t), nil + if !os.IsPermission(err) { + return 0, err } - return 0, err + var info syscall.Sysinfo_t + err = syscall.Sysinfo(&info) + if err != nil { + return 0, err + } + + currentTime := time.Now().UnixNano() / int64(time.Second) + t := currentTime - int64(info.Uptime) + return uint64(t), nil } func readBootTimeStat(ctx context.Context) (uint64, error) { diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_netbsd.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_netbsd.go index 206532126c..52796ddbf5 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_netbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_netbsd.go @@ -4,28 +4,11 @@ package common import ( - "os" - "os/exec" - "strings" "unsafe" "golang.org/x/sys/unix" ) -func DoSysctrl(mib string) ([]string, error) { - cmd := exec.Command("sysctl", "-n", mib) - cmd.Env = getSysctrlEnv(os.Environ()) - out, err := cmd.Output() - if err != nil { - return []string{}, err - } - v := strings.Replace(string(out), "{ ", "", 1) - v = strings.Replace(string(v), " }", "", 1) - values := strings.Fields(string(v)) - - return values, nil -} - func CallSyscall(mib []int32) ([]byte, uint64, error) { mibptr := unsafe.Pointer(&mib[0]) miblen := uint64(len(mib)) diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_openbsd.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_openbsd.go index 00fa19a2fb..df44ac0428 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_openbsd.go @@ -4,28 +4,11 @@ package common import ( - "os" - "os/exec" - "strings" "unsafe" "golang.org/x/sys/unix" ) -func DoSysctrl(mib string) ([]string, error) { - cmd := exec.Command("sysctl", "-n", mib) - cmd.Env = getSysctrlEnv(os.Environ()) - out, err := cmd.Output() - if err != nil { - return []string{}, err - } - v := strings.Replace(string(out), "{ ", "", 1) - v = strings.Replace(string(v), " }", "", 1) - values := strings.Fields(string(v)) - - return values, nil -} - func CallSyscall(mib []int32) ([]byte, uint64, error) { mibptr := unsafe.Pointer(&mib[0]) miblen := uint64(len(mib)) diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_testing.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_testing.go deleted file mode 100644 index 55f36f1f38..0000000000 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_testing.go +++ /dev/null @@ -1,14 +0,0 @@ -// SPDX-License-Identifier: BSD-3-Clause -package common - -import ( - "errors" - "testing" -) - -func SkipIfNotImplementedErr(tb testing.TB, err error) { - tb.Helper() - if errors.Is(err, ErrNotImplementedError) { - tb.Skip("not implemented") - } -} diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go index f3ec5a9864..31df6efe9b 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go @@ -69,6 +69,7 @@ var ( ModNt = windows.NewLazySystemDLL("ntdll.dll") ModPdh = windows.NewLazySystemDLL("pdh.dll") ModPsapi = windows.NewLazySystemDLL("psapi.dll") + ModPowrProf = windows.NewLazySystemDLL("powrprof.dll") ProcGetSystemTimes = Modkernel32.NewProc("GetSystemTimes") ProcNtQuerySystemInformation = ModNt.NewProc("NtQuerySystemInformation") diff --git a/vendor/github.com/shirou/gopsutil/v4/internal/common/warnings.go b/vendor/github.com/shirou/gopsutil/v4/internal/common/warnings.go index 888cc57fae..6bbfc2d722 100644 --- a/vendor/github.com/shirou/gopsutil/v4/internal/common/warnings.go +++ b/vendor/github.com/shirou/gopsutil/v4/internal/common/warnings.go @@ -1,14 +1,28 @@ // SPDX-License-Identifier: BSD-3-Clause package common -import "fmt" +import ( + "fmt" + "strings" +) + +const ( + maxWarnings = 100 // An arbitrary limit to avoid excessive memory usage, it has no sense to store hundreds of errors + tooManyErrorsMessage = "too many errors reported, next errors were discarded" + numberOfWarningsMessage = "Number of warnings:" +) type Warnings struct { - List []error - Verbose bool + List []error + tooManyErrors bool + Verbose bool } func (w *Warnings) Add(err error) { + if len(w.List) >= maxWarnings { + w.tooManyErrors = true + return + } w.List = append(w.List, err) } @@ -22,10 +36,18 @@ func (w *Warnings) Reference() error { func (w *Warnings) Error() string { if w.Verbose { str := "" + var sb strings.Builder for i, e := range w.List { - str += fmt.Sprintf("\tError %d: %s\n", i, e.Error()) + fmt.Fprintf(&sb, "\tError %d: %s\n", i, e.Error()) + } + str += sb.String() + if w.tooManyErrors { + str += fmt.Sprintf("\t%s\n", tooManyErrorsMessage) } return str } - return fmt.Sprintf("Number of warnings: %v", len(w.List)) + if w.tooManyErrors { + return fmt.Sprintf("%s > %v - %s", numberOfWarningsMessage, maxWarnings, tooManyErrorsMessage) + } + return fmt.Sprintf("%s %v", numberOfWarningsMessage, len(w.List)) } diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/ex_linux.go b/vendor/github.com/shirou/gopsutil/v4/mem/ex_linux.go index 0a12fe2fe3..b69dfb605e 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/ex_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/ex_linux.go @@ -14,6 +14,8 @@ type ExVirtualMemory struct { ActiveAnon uint64 `json:"activeanon"` InactiveAnon uint64 `json:"inactiveanon"` Unevictable uint64 `json:"unevictable"` + Percpu uint64 `json:"percpu"` + KernelStack uint64 `json:"kernelstack"` } func (v ExVirtualMemory) String() string { @@ -31,7 +33,7 @@ func (ex *ExLinux) VirtualMemory() (*ExVirtualMemory, error) { return ex.VirtualMemoryWithContext(context.Background()) } -func (ex *ExLinux) VirtualMemoryWithContext(ctx context.Context) (*ExVirtualMemory, error) { +func (*ExLinux) VirtualMemoryWithContext(ctx context.Context) (*ExVirtualMemory, error) { _, vmEx, err := fillFromMeminfoWithContext(ctx) if err != nil { return nil, err diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/ex_windows.go b/vendor/github.com/shirou/gopsutil/v4/mem/ex_windows.go index c1a9ed12da..907143d3ed 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/ex_windows.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/ex_windows.go @@ -27,7 +27,7 @@ func NewExWindows() *ExWindows { return &ExWindows{} } -func (e *ExWindows) VirtualMemory() (*ExVirtualMemory, error) { +func (*ExWindows) VirtualMemory() (*ExVirtualMemory, error) { var memInfo memoryStatusEx memInfo.cbSize = uint32(unsafe.Sizeof(memInfo)) // If mem == 0 since this is an error according to GlobalMemoryStatusEx documentation diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/mem.go b/vendor/github.com/shirou/gopsutil/v4/mem/mem.go index 0da71a9886..f4f46f0d2f 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/mem.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/mem.go @@ -48,10 +48,11 @@ type VirtualMemoryStat struct { Laundry uint64 `json:"laundry"` // Linux specific numbers - // https://www.centos.org/docs/5/html/5.1/Deployment_Guide/s2-proc-meminfo.html + // https://blogs.oracle.com/linux/understanding-linux-kernel-memory-statistics // https://www.kernel.org/doc/Documentation/filesystems/proc.txt // https://www.kernel.org/doc/Documentation/vm/overcommit-accounting // https://www.kernel.org/doc/Documentation/vm/transhuge.txt + // Buffers uint64 `json:"buffers"` Cached uint64 `json:"cached"` WriteBack uint64 `json:"writeBack"` diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/mem_darwin.go b/vendor/github.com/shirou/gopsutil/v4/mem/mem_darwin.go index 7d96a3bb09..1b3e9f21be 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/mem_darwin.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/mem_darwin.go @@ -85,26 +85,23 @@ func VirtualMemory() (*VirtualMemoryStat, error) { } func VirtualMemoryWithContext(_ context.Context) (*VirtualMemoryStat, error) { - machLib, err := common.NewLibrary(common.System) + sys, err := common.NewSystemLib() if err != nil { return nil, err } - defer machLib.Close() - - hostStatistics := common.GetFunc[common.HostStatisticsFunc](machLib, common.HostStatisticsSym) - machHostSelf := common.GetFunc[common.MachHostSelfFunc](machLib, common.MachHostSelfSym) + defer sys.Close() count := uint32(common.HOST_VM_INFO_COUNT) var vmstat vmStatisticsData - status := hostStatistics(machHostSelf(), common.HOST_VM_INFO, + status := sys.HostStatistics(sys.MachHostSelf(), common.HOST_VM_INFO, uintptr(unsafe.Pointer(&vmstat)), &count) if status != common.KERN_SUCCESS { return nil, fmt.Errorf("host_statistics error=%d", status) } - pageSizeAddr, _ := machLib.Dlsym("vm_kernel_page_size") + pageSizeAddr, _ := sys.Dlsym("vm_kernel_page_size") pageSize := **(**uint64)(unsafe.Pointer(&pageSizeAddr)) total, err := getHwMemsize() if err != nil { diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/mem_linux.go b/vendor/github.com/shirou/gopsutil/v4/mem/mem_linux.go index 3e6e4e3e4d..9d969ba839 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/mem_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/mem_linux.go @@ -18,6 +18,13 @@ import ( "github.com/shirou/gopsutil/v4/internal/common" ) +// WillBeDeletedOptOutMemAvailableCalc is a context key to opt out of calculating Mem.Used. +// This is not documented, and will be removed in Mar. 2026. This constant will be removed +// in the future, but it is currently public. The reason is that making it public allows +// developers to notice its removal when their build fails. +// See https://github.com/shirou/gopsutil/issues/1873 +const WillBeDeletedOptOutMemAvailableCalc = "optOutMemAvailableCalc" + func VirtualMemory() (*VirtualMemoryStat, error) { return VirtualMemoryWithContext(context.Background()) } @@ -32,7 +39,10 @@ func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *ExVirtualMemory, error) { filename := common.HostProcWithContext(ctx, "meminfo") - lines, _ := common.ReadLines(filename) + lines, err := common.ReadLines(filename) + if err != nil { + return nil, nil, fmt.Errorf("couldn't read %s: %w", filename, err) + } // flag if MemAvailable is in /proc/meminfo (kernel 3.14+) memavail := false @@ -128,6 +138,12 @@ func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *ExVir return ret, retEx, err } retEx.Unevictable = t * 1024 + case "Percpu": + t, err := strconv.ParseUint(value, 10, 64) + if err != nil { + return ret, retEx, err + } + retEx.Percpu = t * 1024 case "Writeback": t, err := strconv.ParseUint(value, 10, 64) if err != nil { @@ -171,6 +187,12 @@ func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *ExVir return ret, retEx, err } ret.Sunreclaim = t * 1024 + case "KernelStack": + t, err := strconv.ParseUint(value, 10, 64) + if err != nil { + return ret, retEx, err + } + retEx.KernelStack = t * 1024 case "PageTables": t, err := strconv.ParseUint(value, 10, 64) if err != nil { @@ -303,8 +325,17 @@ func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *ExVir ret.Available = ret.Cached + ret.Free } } + // Opt-Out of calculating Mem.Used if the context has the context key set to true. + // This is used for backward compatibility with applications that expect the old calculation method. + // However, we plan to standardize on using MemAvailable in the future. + // Therefore, please avoid using this opt-out unless it is absolutely necessary. + // see https://github.com/shirou/gopsutil/issues/1873 + if val, ok := ctx.Value(WillBeDeletedOptOutMemAvailableCalc).(bool); ok && val { + ret.Used = ret.Total - ret.Free - ret.Buffers - ret.Cached + } else { + ret.Used = ret.Total - ret.Available + } - ret.Used = ret.Total - ret.Free - ret.Buffers - ret.Cached ret.UsedPercent = float64(ret.Used) / float64(ret.Total) * 100.0 return ret, retEx, nil @@ -332,7 +363,10 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { ret.UsedPercent = 0 } filename := common.HostProcWithContext(ctx, "vmstat") - lines, _ := common.ReadLines(filename) + lines, err := common.ReadLines(filename) + if err != nil { + return nil, fmt.Errorf("couldn't read %s: %w", filename, err) + } for _, l := range lines { fields := strings.Fields(l) if len(fields) < 2 { diff --git a/vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go b/vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go index 680cad12b3..1cb785f049 100644 --- a/vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go @@ -61,8 +61,7 @@ func VirtualMemoryWithContext(_ context.Context) (*VirtualMemoryStat, error) { } var bcs Bcachestats br := bytes.NewReader(buf) - err = common.Read(br, binary.LittleEndian, &bcs) - if err != nil { + if err := binary.Read(br, binary.LittleEndian, &bcs); err != nil { return nil, err } ret.Buffers = uint64(bcs.Numbufpages) * p diff --git a/vendor/github.com/shirou/gopsutil/v4/net/net_aix.go b/vendor/github.com/shirou/gopsutil/v4/net/net_aix.go index d5a93f41f8..4531dd4449 100644 --- a/vendor/github.com/shirou/gopsutil/v4/net/net_aix.go +++ b/vendor/github.com/shirou/gopsutil/v4/net/net_aix.go @@ -81,36 +81,36 @@ func parseNetstatNetLine(line string) (ConnectionStat, error) { var portMatch = regexp.MustCompile(`(.*)\.(\d+)$`) +func parseAddr(l string, family uint32) (Addr, error) { + matches := portMatch.FindStringSubmatch(l) + if matches == nil { + return Addr{}, fmt.Errorf("wrong addr, %s", l) + } + host := matches[1] + port := matches[2] + if host == "*" { + switch family { + case syscall.AF_INET: + host = "0.0.0.0" + case syscall.AF_INET6: + host = "::" + default: + return Addr{}, fmt.Errorf("unknown family, %d", family) + } + } + lport, err := strconv.ParseInt(port, 10, 32) + if err != nil { + return Addr{}, err + } + return Addr{IP: host, Port: uint32(lport)}, nil +} + // This function only works for netstat returning addresses with a "." // before the port (0.0.0.0.22 instead of 0.0.0.0:22). func parseNetstatAddr(local, remote string, family uint32) (laddr, raddr Addr, err error) { - parse := func(l string) (Addr, error) { - matches := portMatch.FindStringSubmatch(l) - if matches == nil { - return Addr{}, fmt.Errorf("wrong addr, %s", l) - } - host := matches[1] - port := matches[2] - if host == "*" { - switch family { - case syscall.AF_INET: - host = "0.0.0.0" - case syscall.AF_INET6: - host = "::" - default: - return Addr{}, fmt.Errorf("unknown family, %d", family) - } - } - lport, err := strconv.ParseInt(port, 10, 32) - if err != nil { - return Addr{}, err - } - return Addr{IP: host, Port: uint32(lport)}, nil - } - - laddr, err = parse(local) + laddr, err = parseAddr(local, family) if remote != "*.*" { // remote addr exists - raddr, err = parse(remote) + raddr, err = parseAddr(remote, family) if err != nil { return laddr, raddr, err } diff --git a/vendor/github.com/shirou/gopsutil/v4/net/net_linux.go b/vendor/github.com/shirou/gopsutil/v4/net/net_linux.go index f01b04b503..d1e7f0ce77 100644 --- a/vendor/github.com/shirou/gopsutil/v4/net/net_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/net/net_linux.go @@ -50,26 +50,25 @@ func IOCountersByFileWithContext(_ context.Context, pernic bool, filename string return nil, err } - parts := make([]string, 2) - statlen := len(lines) - 1 ret := make([]IOCountersStat, 0, statlen) for _, line := range lines[2:] { + // Split interface name and stats data at the last ":" separatorPos := strings.LastIndex(line, ":") if separatorPos == -1 { continue } - parts[0] = line[0:separatorPos] - parts[1] = line[separatorPos+1:] + interfacePart := line[0:separatorPos] + statsPart := line[separatorPos+1:] - interfaceName := strings.TrimSpace(parts[0]) + interfaceName := strings.TrimSpace(interfacePart) if interfaceName == "" { continue } - fields := strings.Fields(strings.TrimSpace(parts[1])) + fields := strings.Fields(strings.TrimSpace(statsPart)) bytesRecv, err := strconv.ParseUint(fields[0], 10, 64) if err != nil { return ret, err @@ -610,7 +609,7 @@ func getProcInodesAllWithContext(ctx context.Context, root string, maxConn int) return ret, nil } -// decodeAddress decode addresse represents addr in proc/net/* +// decodeAddress decode address represents addr in proc/net/* // ex: // "0500000A:0016" -> "10.0.0.5", 22 // "0085002452100113070057A13F025401:0035" -> "2400:8500:1301:1052:a157:7:154:23f", 53 diff --git a/vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go b/vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go index 55087ce37d..ec4cfb957f 100644 --- a/vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go @@ -217,34 +217,34 @@ func parseNetstatLine(line string) (ConnectionStat, error) { return n, nil } -func parseNetstatAddr(local, remote string, family uint32) (laddr, raddr Addr, err error) { - parse := func(l string) (Addr, error) { - matches := portMatch.FindStringSubmatch(l) - if matches == nil { - return Addr{}, fmt.Errorf("wrong addr, %s", l) - } - host := matches[1] - port := matches[2] - if host == "*" { - switch family { - case syscall.AF_INET: - host = "0.0.0.0" - case syscall.AF_INET6: - host = "::" - default: - return Addr{}, fmt.Errorf("unknown family, %d", family) - } - } - lport, err := strconv.ParseInt(port, 10, 32) - if err != nil { - return Addr{}, err - } - return Addr{IP: host, Port: uint32(lport)}, nil +func parseAddr(l string, family uint32) (Addr, error) { + matches := portMatch.FindStringSubmatch(l) + if matches == nil { + return Addr{}, fmt.Errorf("wrong addr, %s", l) } + host := matches[1] + port := matches[2] + if host == "*" { + switch family { + case syscall.AF_INET: + host = "0.0.0.0" + case syscall.AF_INET6: + host = "::" + default: + return Addr{}, fmt.Errorf("unknown family, %d", family) + } + } + lport, err := strconv.ParseInt(port, 10, 32) + if err != nil { + return Addr{}, err + } + return Addr{IP: host, Port: uint32(lport)}, nil +} - laddr, err = parse(local) +func parseNetstatAddr(local, remote string, family uint32) (laddr, raddr Addr, err error) { + laddr, err = parseAddr(local, family) if remote != "*.*" { // remote addr exists - raddr, err = parse(remote) + raddr, err = parseAddr(remote, family) if err != nil { return laddr, raddr, err } diff --git a/vendor/github.com/shirou/gopsutil/v4/net/net_unix.go b/vendor/github.com/shirou/gopsutil/v4/net/net_unix.go index 7c5153d308..c491a29113 100644 --- a/vendor/github.com/shirou/gopsutil/v4/net/net_unix.go +++ b/vendor/github.com/shirou/gopsutil/v4/net/net_unix.go @@ -131,26 +131,26 @@ func parseNetLine(line string) (ConnectionStat, error) { return n, nil } -func parseNetAddr(line string) (laddr, raddr Addr, err error) { - parse := func(l string) (Addr, error) { - host, port, err := net.SplitHostPort(l) - if err != nil { - return Addr{}, fmt.Errorf("wrong addr, %s", l) - } - lport, err := strconv.ParseInt(port, 10, 32) - if err != nil { - return Addr{}, err - } - return Addr{IP: host, Port: uint32(lport)}, nil +func parseAddr(l string) (Addr, error) { + host, port, err := net.SplitHostPort(l) + if err != nil { + return Addr{}, fmt.Errorf("wrong addr, %s", l) } + lport, err := strconv.ParseInt(port, 10, 32) + if err != nil { + return Addr{}, err + } + return Addr{IP: host, Port: uint32(lport)}, nil +} +func parseNetAddr(line string) (laddr, raddr Addr, err error) { addrs := strings.Split(line, "->") if len(addrs) == 0 { return laddr, raddr, fmt.Errorf("wrong netaddr, %s", line) } - laddr, err = parse(addrs[0]) + laddr, err = parseAddr(addrs[0]) if len(addrs) == 2 { // remote addr exists - raddr, err = parse(addrs[1]) + raddr, err = parseAddr(addrs[1]) if err != nil { return laddr, raddr, err } diff --git a/vendor/github.com/shirou/gopsutil/v4/net/net_windows.go b/vendor/github.com/shirou/gopsutil/v4/net/net_windows.go index 9622896999..f530e4e573 100644 --- a/vendor/github.com/shirou/gopsutil/v4/net/net_windows.go +++ b/vendor/github.com/shirou/gopsutil/v4/net/net_windows.go @@ -348,7 +348,7 @@ func getTableInfo(filename string, table any) (index, step, length int) { length = int(table.(pmibUDP6TableOwnerPid).DwNumEntries) } - return + return index, step, length } func getTCPConnections(family uint32) ([]ConnectionStat, error) { @@ -533,7 +533,7 @@ func getExtendedTCPTable(pTCPTable uintptr, pdwSize *uint32, bOrder bool, ulAf u if r1 != 0 { errcode = syscall.Errno(r1) } - return + return errcode } func getExtendedUDPTable(pUDPTable uintptr, pdwSize *uint32, bOrder bool, ulAf uint32, tableClass udpTableClass, reserved uint32) (errcode error) { @@ -541,7 +541,7 @@ func getExtendedUDPTable(pUDPTable uintptr, pdwSize *uint32, bOrder bool, ulAf u if r1 != 0 { errcode = syscall.Errno(r1) } - return + return errcode } func getUintptrFromBool(b bool) uintptr { diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process.go b/vendor/github.com/shirou/gopsutil/v4/process/process.go index 0bd4d9e1a1..5db5ff4819 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process.go @@ -5,6 +5,7 @@ import ( "context" "encoding/json" "errors" + "regexp" "runtime" "sort" "sync" @@ -18,6 +19,7 @@ import ( var ( invoke common.Invoker = common.Invoke{} + strictIntPtrn = regexp.MustCompile(`^\d+$`) ErrorNoChildren = errors.New("process does not have children") // Deprecated: ErrorNoChildren is never returned by process.Children(), check its returned []*Process slice length instead ErrorProcessNotRunning = errors.New("process does not exist") ErrorNotPermitted = errors.New("operation not permitted") diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_bsd.go b/vendor/github.com/shirou/gopsutil/v4/process/process_bsd.go index 1a58c3eca3..d094d389d4 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_bsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_bsd.go @@ -16,61 +16,57 @@ type MemoryInfoExStat struct{} type MemoryMapsStat struct{} -func (p *Process) TgidWithContext(_ context.Context) (int32, error) { +func (*Process) TgidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { +func (*Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { +func (*Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { +func (*Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumFDsWithContext(_ context.Context) (int32, error) { - return 0, common.ErrNotImplementedError -} - -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { +func (*Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { +func (*Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { +func (*Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { +func (*Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { +func (*Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) EnvironWithContext(_ context.Context) ([]string, error) { +func (*Process) EnvironWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } func parseKinfoProc(buf []byte) (KinfoProc, error) { var k KinfoProc br := bytes.NewReader(buf) - err := common.Read(br, binary.LittleEndian, &k) + err := binary.Read(br, binary.LittleEndian, &k) return k, err } diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go index 91f3932033..d7fb921cbf 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go @@ -138,7 +138,7 @@ func (p *Process) GidsWithContext(_ context.Context) ([]uint32, error) { return gids, nil } -func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GroupsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError // k, err := p.getKProc() // if err != nil { @@ -153,7 +153,7 @@ func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { // return groups, nil } -func (p *Process) TerminalWithContext(_ context.Context) (string, error) { +func (*Process) TerminalWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError /* k, err := p.getKProc() @@ -179,7 +179,7 @@ func (p *Process) NiceWithContext(_ context.Context) (int32, error) { return int32(k.Proc.P_nice), nil } -func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { +func (*Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { return nil, common.ErrNotImplementedError } @@ -237,7 +237,7 @@ func (p *Process) getKProc() (*unix.KinfoProc, error) { // call ps command. // Return value deletes Header line(you must not input wrong arg). -// And splited by Space. Caller have responsibility to manage. +// And split by Space. Caller have responsibility to manage. // If passed arg pid is 0, get information from all process. func callPsWithContext(ctx context.Context, arg string, pid int32, threadOption, nameOption bool) ([][]string, error) { var cmd []string @@ -279,42 +279,39 @@ func callPsWithContext(ctx context.Context, arg string, pid int32, threadOption, return ret, nil } -var ( - procPidPath common.ProcPidPathFunc - procPidInfo common.ProcPidInfoFunc - machTimeBaseInfo common.MachTimeBaseInfoFunc -) +type dlFuncs struct { + lib *common.SystemLib +} -func registerFuncs() (*common.Library, error) { - lib, err := common.NewLibrary(common.System) +func loadProcFuncs() (*dlFuncs, error) { + lib, err := common.NewSystemLib() if err != nil { return nil, err } - - procPidPath = common.GetFunc[common.ProcPidPathFunc](lib, common.ProcPidPathSym) - procPidInfo = common.GetFunc[common.ProcPidInfoFunc](lib, common.ProcPidInfoSym) - machTimeBaseInfo = common.GetFunc[common.MachTimeBaseInfoFunc](lib, common.MachTimeBaseInfoSym) - - return lib, nil + return &dlFuncs{lib}, err } -func getTimeScaleToNanoSeconds() float64 { +func (f *dlFuncs) getTimeScaleToNanoSeconds() float64 { var timeBaseInfo common.MachTimeBaseInfo - machTimeBaseInfo(uintptr(unsafe.Pointer(&timeBaseInfo))) + f.lib.MachTimeBaseInfo(uintptr(unsafe.Pointer(&timeBaseInfo))) return float64(timeBaseInfo.Numer) / float64(timeBaseInfo.Denom) } +func (f *dlFuncs) Close() { + f.lib.Close() +} + func (p *Process) ExeWithContext(_ context.Context) (string, error) { - lib, err := registerFuncs() + funcs, err := loadProcFuncs() if err != nil { return "", err } - defer lib.Close() + defer funcs.Close() buf := common.NewCStr(common.PROC_PIDPATHINFO_MAXSIZE) - ret := procPidPath(p.Pid, buf.Addr(), common.PROC_PIDPATHINFO_MAXSIZE) + ret := funcs.lib.ProcPidPath(p.Pid, buf.Addr(), common.PROC_PIDPATHINFO_MAXSIZE) if ret <= 0 { return "", fmt.Errorf("unknown error: proc_pidpath returned %d", ret) @@ -323,24 +320,17 @@ func (p *Process) ExeWithContext(_ context.Context) (string, error) { return buf.GoString(), nil } -// sys/proc_info.h -type vnodePathInfo struct { - _ [152]byte - vipPath [common.MAXPATHLEN]byte - _ [1176]byte -} - // CwdWithContext retrieves the Current Working Directory for the given process. // It uses the proc_pidinfo from libproc and will only work for processes the // EUID can access. Otherwise "operation not permitted" will be returned as the // error. // Note: This might also work for other *BSD OSs. func (p *Process) CwdWithContext(_ context.Context) (string, error) { - lib, err := registerFuncs() + funcs, err := loadProcFuncs() if err != nil { return "", err } - defer lib.Close() + defer funcs.Close() // Lock OS thread to ensure the errno does not change runtime.LockOSThread() @@ -348,8 +338,8 @@ func (p *Process) CwdWithContext(_ context.Context) (string, error) { var vpi vnodePathInfo const vpiSize = int32(unsafe.Sizeof(vpi)) - ret := procPidInfo(p.Pid, common.PROC_PIDVNODEPATHINFO, 0, uintptr(unsafe.Pointer(&vpi)), vpiSize) - errno, _ := lib.Dlsym("errno") + ret := funcs.lib.ProcPidInfo(p.Pid, common.PROC_PIDVNODEPATHINFO, 0, uintptr(unsafe.Pointer(&vpi)), vpiSize) + errno, _ := funcs.lib.Dlsym("errno") err = *(**unix.Errno)(unsafe.Pointer(&errno)) if errors.Is(err, unix.EPERM) { return "", ErrorNotPermitted @@ -362,11 +352,11 @@ func (p *Process) CwdWithContext(_ context.Context) (string, error) { if ret != vpiSize { return "", fmt.Errorf("too few bytes; expected %d, got %d", vpiSize, ret) } - return common.GoString(&vpi.vipPath[0]), nil + return common.GoString((*byte)(unsafe.Pointer(&vpi.Cdir.Path[0]))), nil } func procArgs(pid int32) ([]byte, int, error) { - procargs, _, err := common.CallSyscall([]int32{common.CTL_KERN, common.KERN_PROCARGS2, pid}) + procargs, err := unix.SysctlRaw("kern.procargs2", int(pid)) if err != nil { return nil, 0, err } @@ -433,29 +423,29 @@ func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) { } func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { - lib, err := registerFuncs() + funcs, err := loadProcFuncs() if err != nil { return 0, err } - defer lib.Close() + defer funcs.Close() var ti ProcTaskInfo - procPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) + funcs.lib.ProcPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) return int32(ti.Threadnum), nil } func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { - lib, err := registerFuncs() + funcs, err := loadProcFuncs() if err != nil { return nil, err } - defer lib.Close() + defer funcs.Close() var ti ProcTaskInfo - procPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) + funcs.lib.ProcPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) - timescaleToNanoSeconds := getTimeScaleToNanoSeconds() + timescaleToNanoSeconds := funcs.getTimeScaleToNanoSeconds() ret := &cpu.TimesStat{ CPU: "cpu", User: float64(ti.Total_user) * timescaleToNanoSeconds / 1e9, @@ -465,14 +455,14 @@ func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { } func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { - lib, err := registerFuncs() + funcs, err := loadProcFuncs() if err != nil { return nil, err } - defer lib.Close() + defer funcs.Close() var ti ProcTaskInfo - procPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) + funcs.lib.ProcPidInfo(p.Pid, common.PROC_PIDTASKINFO, 0, uintptr(unsafe.Pointer(&ti)), int32(unsafe.Sizeof(ti))) ret := &MemoryInfoStat{ RSS: uint64(ti.Resident_size), @@ -481,3 +471,54 @@ func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, err } return ret, nil } + +// procFDInfo represents a file descriptor entry from sys/proc_info.h +type procFDInfo struct { + ProcFd int32 + ProcFdtype uint32 +} + +// NumFDsWithContext returns the number of file descriptors used by the process. +// It uses proc_pidinfo with PROC_PIDLISTFDS to query the kernel for the count +// of open file descriptors. The method makes a single syscall and calculates +// the count from the buffer size returned by the kernel. +func (p *Process) NumFDsWithContext(_ context.Context) (int32, error) { + funcs, err := loadProcFuncs() + if err != nil { + return 0, err + } + defer funcs.Close() + + // First call: get required buffer size + bufferSize := funcs.lib.ProcPidInfo( + p.Pid, + common.PROC_PIDLISTFDS, + 0, + 0, // NULL buffer + 0, // 0 size + ) + if bufferSize <= 0 { + return 0, fmt.Errorf("unknown error: proc_pidinfo returned %d", bufferSize) + } + + // Allocate buffer of the required size + const sizeofProcFDInfo = int32(unsafe.Sizeof(procFDInfo{})) + numEntries := bufferSize / sizeofProcFDInfo + buf := make([]procFDInfo, numEntries) + + // Second call: get actual data + ret := funcs.lib.ProcPidInfo( + p.Pid, + common.PROC_PIDLISTFDS, + 0, + uintptr(unsafe.Pointer(&buf[0])), // Real buffer + bufferSize, // Size from first call + ) + if ret <= 0 { + return 0, fmt.Errorf("unknown error: proc_pidinfo returned %d", ret) + } + + // Calculate actual number of FDs returned + numFDs := ret / sizeofProcFDInfo + return numFDs, nil +} diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_amd64.go b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_amd64.go index 890a5d5331..a40f96195d 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_amd64.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_amd64.go @@ -233,6 +233,51 @@ type ProcTaskInfo struct { Priority int32 } +type vinfoStat struct { + Dev uint32 + Mode uint16 + Nlink uint16 + Ino uint64 + Uid uint32 + Gid uint32 + Atime int64 + Atimensec int64 + Mtime int64 + Mtimensec int64 + Ctime int64 + Ctimensec int64 + Birthtime int64 + Birthtimensec int64 + Size int64 + Blocks int64 + Blksize int32 + Flags uint32 + Gen uint32 + Rdev uint32 + Qspare [2]int64 +} + +type fsid struct { + Val [2]int32 +} + +type vnodeInfo struct { + Stat vinfoStat + Type int32 + Pad int32 + Fsid fsid +} + +type vnodeInfoPath struct { + Vi vnodeInfo + Path [1024]int8 +} + +type vnodePathInfo struct { + Cdir vnodeInfoPath + Rdir vnodeInfoPath +} + type AuditinfoAddr struct { Auid uint32 Mask AuMask diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_arm64.go b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_arm64.go index 8075cf227d..7ab1afb117 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_arm64.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_darwin_arm64.go @@ -211,6 +211,51 @@ type ProcTaskInfo struct { Priority int32 } +type vinfoStat struct { + Dev uint32 + Mode uint16 + Nlink uint16 + Ino uint64 + Uid uint32 + Gid uint32 + Atime int64 + Atimensec int64 + Mtime int64 + Mtimensec int64 + Ctime int64 + Ctimensec int64 + Birthtime int64 + Birthtimensec int64 + Size int64 + Blocks int64 + Blksize int32 + Flags uint32 + Gen uint32 + Rdev uint32 + Qspare [2]int64 +} + +type fsid struct { + Val [2]int32 +} + +type vnodeInfo struct { + Stat vinfoStat + Type int32 + Pad int32 + Fsid fsid +} + +type vnodeInfoPath struct { + Vi vnodeInfo + Path [1024]int8 +} + +type vnodePathInfo struct { + Cdir vnodeInfoPath + Rdir vnodeInfoPath +} + type AuditinfoAddr struct { Auid uint32 Mask AuMask diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_fallback.go b/vendor/github.com/shirou/gopsutil/v4/process/process_fallback.go index b014297348..699311a9ca 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_fallback.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_fallback.go @@ -42,162 +42,162 @@ func PidExistsWithContext(_ context.Context, _ int32) (bool, error) { return false, common.ErrNotImplementedError } -func (p *Process) PpidWithContext(_ context.Context) (int32, error) { +func (*Process) PpidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) NameWithContext(_ context.Context) (string, error) { +func (*Process) NameWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) TgidWithContext(_ context.Context) (int32, error) { +func (*Process) TgidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) ExeWithContext(_ context.Context) (string, error) { +func (*Process) ExeWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) CmdlineWithContext(_ context.Context) (string, error) { +func (*Process) CmdlineWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) CmdlineSliceWithContext(_ context.Context) ([]string, error) { +func (*Process) CmdlineSliceWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } -func (p *Process) createTimeWithContext(_ context.Context) (int64, error) { +func (*Process) createTimeWithContext(_ context.Context) (int64, error) { return 0, common.ErrNotImplementedError } -func (p *Process) CwdWithContext(_ context.Context) (string, error) { +func (*Process) CwdWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) StatusWithContext(_ context.Context) ([]string, error) { +func (*Process) StatusWithContext(_ context.Context) ([]string, error) { return []string{""}, common.ErrNotImplementedError } -func (p *Process) ForegroundWithContext(_ context.Context) (bool, error) { +func (*Process) ForegroundWithContext(_ context.Context) (bool, error) { return false, common.ErrNotImplementedError } -func (p *Process) UidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) UidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GroupsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TerminalWithContext(_ context.Context) (string, error) { +func (*Process) TerminalWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) NiceWithContext(_ context.Context) (int32, error) { +func (*Process) NiceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { +func (*Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { +func (*Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { +func (*Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { +func (*Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumFDsWithContext(_ context.Context) (int32, error) { +func (*Process) NumFDsWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { +func (*Process) NumThreadsWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { +func (*Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { +func (*Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { +func (*Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { +func (*Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { +func (*Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { +func (*Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { return nil, common.ErrNotImplementedError } -func (p *Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { +func (*Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { +func (*Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) SendSignalWithContext(_ context.Context, _ Signal) error { +func (*Process) SendSignalWithContext(_ context.Context, _ Signal) error { return common.ErrNotImplementedError } -func (p *Process) SuspendWithContext(_ context.Context) error { +func (*Process) SuspendWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) ResumeWithContext(_ context.Context) error { +func (*Process) ResumeWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) TerminateWithContext(_ context.Context) error { +func (*Process) TerminateWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) KillWithContext(_ context.Context) error { +func (*Process) KillWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) UsernameWithContext(_ context.Context) (string, error) { +func (*Process) UsernameWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) EnvironWithContext(_ context.Context) ([]string, error) { +func (*Process) EnvironWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_freebsd.go b/vendor/github.com/shirou/gopsutil/v4/process/process_freebsd.go index 6df31421c3..283af9bb3f 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_freebsd.go @@ -79,7 +79,7 @@ func (p *Process) CwdWithContext(_ context.Context) (string, error) { var k kinfoFile br := bytes.NewReader(buf) - if err := common.Read(br, binary.LittleEndian, &k); err != nil { + if err := binary.Read(br, binary.LittleEndian, &k); err != nil { return "", err } cwd := common.IntToString(k.Path[:]) @@ -279,7 +279,7 @@ func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, err if err != nil { return nil, err } - pageSize := common.LittleEndian.Uint16([]byte(v)) + pageSize := binary.LittleEndian.Uint16([]byte(v)) return &MemoryInfoStat{ RSS: uint64(k.Rssize) * uint64(pageSize), @@ -344,6 +344,10 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) { return results, nil } +func (*Process) NumFDsWithContext(_ context.Context) (int32, error) { + return 0, common.ErrNotImplementedError +} + func (p *Process) getKProc() (*KinfoProc, error) { mib := []int32{CTLKern, KernProc, KernProcPID, p.Pid} diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_linux.go b/vendor/github.com/shirou/gopsutil/v4/process/process_linux.go index f44f6bc6f7..764523dcf7 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_linux.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_linux.go @@ -194,7 +194,7 @@ func (p *Process) NiceWithContext(ctx context.Context) (int32, error) { return nice, nil } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } @@ -310,7 +310,7 @@ func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) return cpuTimes, nil } -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } @@ -346,7 +346,7 @@ func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) { ret := make([]*Process, 0, len(statFiles)) for _, statFile := range statFiles { statContents, err := os.ReadFile(statFile) - if err != nil { + if err != nil || len(statContents) == 0 { continue } fields := splitProcStat(statContents) @@ -880,7 +880,7 @@ func (p *Process) fillFromStatusWithContext(ctx context.Context) error { case "Uid": p.uids = make([]uint32, 0, 4) for _, i := range strings.Split(value, "\t") { - v, err := strconv.ParseInt(i, 10, 32) + v, err := strconv.ParseUint(i, 10, 32) if err != nil { return err } @@ -889,7 +889,7 @@ func (p *Process) fillFromStatusWithContext(ctx context.Context) error { case "Gid": p.gids = make([]uint32, 0, 4) for _, i := range strings.Split(value, "\t") { - v, err := strconv.ParseInt(i, 10, 32) + v, err := strconv.ParseUint(i, 10, 32) if err != nil { return err } @@ -924,49 +924,49 @@ func (p *Process) fillFromStatusWithContext(ctx context.Context) error { } p.numCtxSwitches.Involuntary = v case "VmRSS": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.RSS = v * 1024 case "VmSize": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.VMS = v * 1024 case "VmSwap": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.Swap = v * 1024 case "VmHWM": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.HWM = v * 1024 case "VmData": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.Data = v * 1024 case "VmStk": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err } p.memInfo.Stack = v * 1024 case "VmLck": - value := strings.Trim(value, " kB") // remove last "kB" + value = strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) if err != nil { return err @@ -1038,6 +1038,9 @@ func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (ui } contents, err := os.ReadFile(statPath) + if err == nil && len(contents) == 0 { + err = fmt.Errorf("process %d: stat file is empty, process may have terminated", pid) + } if err != nil { return 0, 0, nil, 0, 0, 0, nil, err } @@ -1173,6 +1176,9 @@ func readPidsFromDir(path string) ([]int32, error) { return nil, err } for _, fname := range fnames { + if !strictIntPtrn.MatchString(fname) { + continue + } pid, err := strconv.ParseInt(fname, 10, 32) if err != nil { // if not numeric name, just skip diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go b/vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go index 063ff20ca2..31fdb85bc9 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go @@ -78,7 +78,7 @@ func (p *Process) CwdWithContext(_ context.Context) (string, error) { return common.ByteToString(buf), nil } -func (p *Process) ExeWithContext(_ context.Context) (string, error) { +func (*Process) ExeWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } @@ -142,7 +142,7 @@ func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) { return strings.Join(argv, " "), nil } -func (p *Process) createTimeWithContext(_ context.Context) (int64, error) { +func (*Process) createTimeWithContext(_ context.Context) (int64, error) { return 0, common.ErrNotImplementedError } @@ -252,7 +252,7 @@ func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, err }, nil } -func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { +func (*Process) NumThreadsWithContext(_ context.Context) (int32, error) { /* not supported, just return 1 */ return 1, nil } @@ -305,11 +305,11 @@ func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) { return ret, nil } -func (p *Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } @@ -342,6 +342,10 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) { return results, nil } +func (*Process) NumFDsWithContext(_ context.Context) (int32, error) { + return 0, common.ErrNotImplementedError +} + func (p *Process) getKProc() (*KinfoProc, error) { buf, length, err := callKernProcSyscall(KernProcPID, p.Pid) if err != nil { diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_plan9.go b/vendor/github.com/shirou/gopsutil/v4/process/process_plan9.go index 7f68771823..bdb07ff285 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_plan9.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_plan9.go @@ -42,162 +42,162 @@ func PidExistsWithContext(_ context.Context, _ int32) (bool, error) { return false, common.ErrNotImplementedError } -func (p *Process) PpidWithContext(_ context.Context) (int32, error) { +func (*Process) PpidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) NameWithContext(_ context.Context) (string, error) { +func (*Process) NameWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) TgidWithContext(_ context.Context) (int32, error) { +func (*Process) TgidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) ExeWithContext(_ context.Context) (string, error) { +func (*Process) ExeWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) CmdlineWithContext(_ context.Context) (string, error) { +func (*Process) CmdlineWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) CmdlineSliceWithContext(_ context.Context) ([]string, error) { +func (*Process) CmdlineSliceWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } -func (p *Process) createTimeWithContext(_ context.Context) (int64, error) { +func (*Process) createTimeWithContext(_ context.Context) (int64, error) { return 0, common.ErrNotImplementedError } -func (p *Process) CwdWithContext(_ context.Context) (string, error) { +func (*Process) CwdWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) StatusWithContext(_ context.Context) ([]string, error) { +func (*Process) StatusWithContext(_ context.Context) ([]string, error) { return []string{""}, common.ErrNotImplementedError } -func (p *Process) ForegroundWithContext(_ context.Context) (bool, error) { +func (*Process) ForegroundWithContext(_ context.Context) (bool, error) { return false, common.ErrNotImplementedError } -func (p *Process) UidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) UidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GroupsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TerminalWithContext(_ context.Context) (string, error) { +func (*Process) TerminalWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) NiceWithContext(_ context.Context) (int32, error) { +func (*Process) NiceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { +func (*Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { +func (*Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { +func (*Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { +func (*Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumFDsWithContext(_ context.Context) (int32, error) { +func (*Process) NumFDsWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { +func (*Process) NumThreadsWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { +func (*Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { +func (*Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { +func (*Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { +func (*Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { +func (*Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { +func (*Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { return nil, common.ErrNotImplementedError } -func (p *Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { +func (*Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { +func (*Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) SendSignalWithContext(_ context.Context, _ Signal) error { +func (*Process) SendSignalWithContext(_ context.Context, _ Signal) error { return common.ErrNotImplementedError } -func (p *Process) SuspendWithContext(_ context.Context) error { +func (*Process) SuspendWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) ResumeWithContext(_ context.Context) error { +func (*Process) ResumeWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) TerminateWithContext(_ context.Context) error { +func (*Process) TerminateWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) KillWithContext(_ context.Context) error { +func (*Process) KillWithContext(_ context.Context) error { return common.ErrNotImplementedError } -func (p *Process) UsernameWithContext(_ context.Context) (string, error) { +func (*Process) UsernameWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) EnvironWithContext(_ context.Context) ([]string, error) { +func (*Process) EnvironWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_posix.go b/vendor/github.com/shirou/gopsutil/v4/process/process_posix.go index 9fe55b490e..06642238df 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_posix.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_posix.go @@ -26,7 +26,9 @@ func getTerminalMap() (map[uint64]string, error) { ret := make(map[uint64]string) var termfiles []string - d, err := os.Open("/dev") + devPath := common.HostDev() + + d, err := os.Open(devPath) if err != nil { return nil, err } @@ -37,32 +39,29 @@ func getTerminalMap() (map[uint64]string, error) { return nil, err } for _, devname := range devnames { - if strings.HasPrefix(devname, "/dev/tty") { - termfiles = append(termfiles, "/dev/tty/"+devname) + if strings.HasPrefix(devname, "tty") { + termfiles = append(termfiles, filepath.Join(devPath, devname)) } } var ptsnames []string - ptsd, err := os.Open("/dev/pts") + ptsPath := filepath.Join(devPath, "pts") + ptsd, err := os.Open(ptsPath) if err != nil { - ptsnames, _ = filepath.Glob("/dev/ttyp*") + ptsnames, _ = filepath.Glob(filepath.Join(devPath, "ttyp*")) if ptsnames == nil { return nil, err } - } - defer ptsd.Close() - - if ptsnames == nil { + termfiles = append(termfiles, ptsnames...) + } else { defer ptsd.Close() ptsnames, err = ptsd.Readdirnames(-1) if err != nil { return nil, err } for _, ptsname := range ptsnames { - termfiles = append(termfiles, "/dev/pts/"+ptsname) + termfiles = append(termfiles, filepath.Join(ptsPath, ptsname)) } - } else { - termfiles = ptsnames } for _, name := range termfiles { @@ -72,7 +71,7 @@ func getTerminalMap() (map[uint64]string, error) { return nil, err } rdev := uint64(stat.Rdev) - ret[rdev] = strings.ReplaceAll(name, "/dev", "") + ret[rdev] = strings.TrimPrefix(name, devPath+string(os.PathSeparator)) } return ret, nil } @@ -112,7 +111,7 @@ func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) { defer proc.Release() if isMount(common.HostProcWithContext(ctx)) { // if //proc exists and is mounted, check if //proc/ folder exists - _, err := os.Stat(common.HostProcWithContext(ctx, strconv.Itoa(int(pid)))) + _, err := os.Stat(common.HostProcWithContext(ctx, strconv.Itoa(int(pid)))) //nolint:gosec // pid is int32, path traversal is not possible if os.IsNotExist(err) { return false, nil } diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go b/vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go index 6af5633e06..547d228721 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go @@ -52,15 +52,15 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) { return out, nil } -func (p *Process) PpidWithContext(_ context.Context) (int32, error) { +func (*Process) PpidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) NameWithContext(_ context.Context) (string, error) { +func (*Process) NameWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) TgidWithContext(_ context.Context) (int32, error) { +func (*Process) TgidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } @@ -80,7 +80,7 @@ func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) return p.fillSliceFromCmdlineWithContext(ctx) } -func (p *Process) createTimeWithContext(_ context.Context) (int64, error) { +func (*Process) createTimeWithContext(_ context.Context) (int64, error) { return 0, common.ErrNotImplementedError } @@ -88,51 +88,51 @@ func (p *Process) CwdWithContext(ctx context.Context) (string, error) { return p.fillFromPathCwdWithContext(ctx) } -func (p *Process) StatusWithContext(_ context.Context) ([]string, error) { +func (*Process) StatusWithContext(_ context.Context) ([]string, error) { return []string{""}, common.ErrNotImplementedError } -func (p *Process) ForegroundWithContext(_ context.Context) (bool, error) { +func (*Process) ForegroundWithContext(_ context.Context) (bool, error) { return false, common.ErrNotImplementedError } -func (p *Process) UidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) UidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GroupsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TerminalWithContext(_ context.Context) (string, error) { +func (*Process) TerminalWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } -func (p *Process) NiceWithContext(_ context.Context) (int32, error) { +func (*Process) NiceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { +func (*Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { +func (*Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { +func (*Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { +func (*Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { return nil, common.ErrNotImplementedError } @@ -141,55 +141,55 @@ func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) { return int32(len(fnames)), err } -func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { +func (*Process) NumThreadsWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { +func (*Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { +func (*Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { +func (*Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { +func (*Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { +func (*Process) PageFaultsWithContext(_ context.Context) (*PageFaultsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { +func (*Process) ChildrenWithContext(_ context.Context) ([]*Process, error) { return nil, common.ErrNotImplementedError } -func (p *Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { +func (*Process) OpenFilesWithContext(_ context.Context) ([]OpenFilesStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsWithContext(_ context.Context) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { +func (*Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) EnvironWithContext(_ context.Context) ([]string, error) { +func (*Process) EnvironWithContext(_ context.Context) ([]string, error) { return nil, common.ErrNotImplementedError } @@ -289,6 +289,9 @@ func readPidsFromDir(path string) ([]int32, error) { return nil, err } for _, fname := range fnames { + if !strictIntPtrn.MatchString(fname) { + continue + } pid, err := strconv.ParseInt(fname, 10, 32) if err != nil { // if not numeric name, just skip diff --git a/vendor/github.com/shirou/gopsutil/v4/process/process_windows.go b/vendor/github.com/shirou/gopsutil/v4/process/process_windows.go index b4748d38e7..a1e28be698 100644 --- a/vendor/github.com/shirou/gopsutil/v4/process/process_windows.go +++ b/vendor/github.com/shirou/gopsutil/v4/process/process_windows.go @@ -202,10 +202,10 @@ type ( ) func init() { - var systemInfo systemInfo + var sInfo systemInfo - procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&systemInfo))) - processorArchitecture = uint(systemInfo.wProcessorArchitecture) + procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&sInfo))) + processorArchitecture = uint(sInfo.wProcessorArchitecture) // enable SeDebugPrivilege https://github.com/midstar/proci/blob/6ec79f57b90ba3d9efa2a7b16ef9c9369d4be875/proci_windows.go#L80-L119 handle, err := syscall.GetCurrentProcess() @@ -336,7 +336,7 @@ func (p *Process) NameWithContext(ctx context.Context) (string, error) { return filepath.Base(exe), nil } -func (p *Process) TgidWithContext(_ context.Context) (int32, error) { +func (*Process) TgidWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } @@ -456,11 +456,11 @@ func (p *Process) CwdWithContext(_ context.Context) (string, error) { return "", nil } -func (p *Process) StatusWithContext(_ context.Context) ([]string, error) { +func (*Process) StatusWithContext(_ context.Context) ([]string, error) { return []string{""}, common.ErrNotImplementedError } -func (p *Process) ForegroundWithContext(_ context.Context) (bool, error) { +func (*Process) ForegroundWithContext(_ context.Context) (bool, error) { return false, common.ErrNotImplementedError } @@ -487,19 +487,19 @@ func (p *Process) UsernameWithContext(_ context.Context) (string, error) { return domain + "\\" + user, err } -func (p *Process) UidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) UidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GidsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GidsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) GroupsWithContext(_ context.Context) ([]uint32, error) { +func (*Process) GroupsWithContext(_ context.Context) ([]uint32, error) { return nil, common.ErrNotImplementedError } -func (p *Process) TerminalWithContext(_ context.Context) (string, error) { +func (*Process) TerminalWithContext(_ context.Context) (string, error) { return "", common.ErrNotImplementedError } @@ -532,15 +532,15 @@ func (p *Process) NiceWithContext(_ context.Context) (int32, error) { return priority, nil } -func (p *Process) IOniceWithContext(_ context.Context) (int32, error) { +func (*Process) IOniceWithContext(_ context.Context) (int32, error) { return 0, common.ErrNotImplementedError } -func (p *Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { +func (*Process) RlimitWithContext(_ context.Context) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { +func (*Process) RlimitUsageWithContext(_ context.Context, _ bool) ([]RlimitStat, error) { return nil, common.ErrNotImplementedError } @@ -550,22 +550,22 @@ func (p *Process) IOCountersWithContext(_ context.Context) (*IOCountersStat, err return nil, err } defer windows.CloseHandle(c) - var ioCounters ioCounters - ret, _, err := procGetProcessIoCounters.Call(uintptr(c), uintptr(unsafe.Pointer(&ioCounters))) + var counters ioCounters + ret, _, err := procGetProcessIoCounters.Call(uintptr(c), uintptr(unsafe.Pointer(&counters))) if ret == 0 { return nil, err } stats := &IOCountersStat{ - ReadCount: ioCounters.ReadOperationCount, - ReadBytes: ioCounters.ReadTransferCount, - WriteCount: ioCounters.WriteOperationCount, - WriteBytes: ioCounters.WriteTransferCount, + ReadCount: counters.ReadOperationCount, + ReadBytes: counters.ReadTransferCount, + WriteCount: counters.WriteOperationCount, + WriteBytes: counters.WriteTransferCount, } return stats, nil } -func (p *Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { +func (*Process) NumCtxSwitchesWithContext(_ context.Context) (*NumCtxSwitchesStat, error) { return nil, common.ErrNotImplementedError } @@ -601,7 +601,7 @@ func (p *Process) NumThreadsWithContext(_ context.Context) (int32, error) { return ret, nil } -func (p *Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { +func (*Process) ThreadsWithContext(_ context.Context) (map[int32]*cpu.TimesStat, error) { return nil, common.ErrNotImplementedError } @@ -629,7 +629,7 @@ func (p *Process) TimesWithContext(_ context.Context) (*cpu.TimesStat, error) { }, nil } -func (p *Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { +func (*Process) CPUAffinityWithContext(_ context.Context) ([]int32, error) { return nil, common.ErrNotImplementedError } @@ -647,7 +647,7 @@ func (p *Process) MemoryInfoWithContext(_ context.Context) (*MemoryInfoStat, err return ret, nil } -func (p *Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { +func (*Process) MemoryInfoExWithContext(_ context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } @@ -699,6 +699,7 @@ func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, er if err != nil { return nil, err } + defer windows.CloseHandle(process) buffer := make([]byte, 1024) var size uint32 @@ -747,9 +748,10 @@ func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, er } var fileName string - ch := make(chan struct{}) + ch := make(chan struct{}, 1) go func() { + defer close(ch) var buf [syscall.MAX_LONG_PATH]uint16 n, err := windows.GetFinalPathNameByHandle(windows.Handle(file), &buf[0], syscall.MAX_LONG_PATH, 0) if err != nil { @@ -788,15 +790,15 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return net.ConnectionsPidWithContext(ctx, "all", p.Pid) } -func (p *Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { +func (*Process) ConnectionsMaxWithContext(_ context.Context, _ int) ([]net.ConnectionStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { +func (*Process) MemoryMapsWithContext(_ context.Context, _ bool) (*[]MemoryMapsStat, error) { return nil, common.ErrNotImplementedError } -func (p *Process) SendSignalWithContext(_ context.Context, _ syscall.Signal) error { +func (*Process) SendSignalWithContext(_ context.Context, _ syscall.Signal) error { return common.ErrNotImplementedError } @@ -956,7 +958,7 @@ func getProcessMemoryInfo(h windows.Handle, mem *PROCESS_MEMORY_COUNTERS) (err e err = syscall.EINVAL } } - return + return err } type SYSTEM_TIMES struct { //nolint:revive //FIXME diff --git a/vendor/github.com/testcontainers/testcontainers-go/.gitignore b/vendor/github.com/testcontainers/testcontainers-go/.gitignore index b5fd75ccce..1693b100b6 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/.gitignore +++ b/vendor/github.com/testcontainers/testcontainers-go/.gitignore @@ -23,3 +23,6 @@ TEST-*.xml # Coverage files coverage.out + +# Usage metrics script binary +usage-metrics/scripts/collect-metrics diff --git a/vendor/github.com/testcontainers/testcontainers-go/.golangci.yml b/vendor/github.com/testcontainers/testcontainers-go/.golangci.yml index 05ecd658eb..6f68a9370f 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/.golangci.yml +++ b/vendor/github.com/testcontainers/testcontainers-go/.golangci.yml @@ -23,6 +23,27 @@ linters: - thelper - usestdlibvars exclusions: + rules: + - linters: + - revive + path: "^exec/" + text: "var-naming: avoid package names that conflict with Go standard library package names" + - linters: + - revive + path: "^log/" + text: "var-naming: avoid package names that conflict with Go standard library package names" + - linters: + - revive + path: "modulegen/internal/(context|template)/" + text: "var-naming: avoid package names that conflict with Go standard library package names" + - linters: + - revive + path: "internal/sdk/types/" + text: "var-naming: avoid meaningless package names" + - linters: + - revive + path: "gcloud/internal/shared/" + text: "var-naming: avoid meaningless package names" presets: - comments - common-false-positives diff --git a/vendor/github.com/testcontainers/testcontainers-go/AI.md b/vendor/github.com/testcontainers/testcontainers-go/AI.md index 9d1e91d321..c66a8c69b8 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/AI.md +++ b/vendor/github.com/testcontainers/testcontainers-go/AI.md @@ -14,15 +14,15 @@ This is a **Go monorepo** containing: ## Environment Setup ### Go Version -- **Required**: Go 1.24.7 +- **Required**: Go 1.25.7 - **Tool**: Use [gvm](https://github.com/andrewkroh/gvm) for version management - **CRITICAL**: Always run this before ANY Go command: ```bash # For Apple Silicon (M1/M2/M3) - eval "$(gvm 1.24.7 --arch=arm64)" + eval "$(gvm 1.25.7 --arch=arm64)" # For Intel/AMD (x86_64) - eval "$(gvm 1.24.7 --arch=amd64)" + eval "$(gvm 1.25.7 --arch=amd64)" ``` ### Project Structure @@ -171,14 +171,14 @@ func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustom ### When Tests Fail 1. **Read the error message carefully** - it usually tells you exactly what's wrong 2. **Check if it's a lint issue** - run `make pre-commit` first -3. **Verify Go version** - ensure using Go 1.24.7 +3. **Verify Go version** - ensure using Go 1.25.7 4. **Check Docker** - some tests require Docker daemon running ## Common Pitfalls to Avoid ### Code Issues - ❌ Using interface types as return values -- ❌ Forgetting to run `eval "$(gvm 1.24.7 --arch=arm64)"` +- ❌ Forgetting to run `eval "$(gvm 1.25.7 --arch=arm64)"` - ❌ Not handling errors from built-in options - ❌ Using module-specific container names (`PostgresContainer`) - ❌ Calling `.Customize()` method instead of direct function call diff --git a/vendor/github.com/testcontainers/testcontainers-go/Makefile b/vendor/github.com/testcontainers/testcontainers-go/Makefile index de6ccbd887..5b7c500015 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/Makefile +++ b/vendor/github.com/testcontainers/testcontainers-go/Makefile @@ -46,7 +46,7 @@ serve-docs: # # - compose-clean: Clean the .build directory, and clean the go.mod and go.sum files in the testcontainers-go compose module. # - compose-clone: Clone the compose and compose-go repositories into the .build directory. -# - compose-replace: Replace the docker/compose/v2 dependency in the testcontainers-go compose module with the local copy. +# - compose-replace: Replace the docker/compose/v5 dependency in the testcontainers-go compose module with the local copy. # - compose-spec-replace: Replace the compose-spec/compose-go/v2 dependency in the testcontainers-go compose module with the local copy. # - compose-tidy: Run "go mod tidy" in the testcontainers-go compose module. # - compose-test-all-latest: Test the testcontainers-go compose module against the latest versions of the compose and compose-go repositories. @@ -67,7 +67,7 @@ compose-clone: compose-clean .PHONY: compose-replace compose-replace: - cd modules/compose && echo "replace github.com/docker/compose/v2 => ../../.build/compose" >> go.mod + cd modules/compose && echo "replace github.com/docker/compose/v5 => ../../.build/compose" >> go.mod .PHONY: compose-spec-replace compose-spec-replace: diff --git a/vendor/github.com/testcontainers/testcontainers-go/Pipfile b/vendor/github.com/testcontainers/testcontainers-go/Pipfile index a194691389..28f9305d01 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/Pipfile +++ b/vendor/github.com/testcontainers/testcontainers-go/Pipfile @@ -7,8 +7,8 @@ verify_ssl = true [packages] mkdocs = "==1.5.3" -mkdocs-codeinclude-plugin = "==0.2.1" -mkdocs-include-markdown-plugin = "==7.2.0" +mkdocs-codeinclude-plugin = "==0.3.1" +mkdocs-include-markdown-plugin = "==7.2.1" mkdocs-material = "==9.5.18" mkdocs-markdownextradata-plugin = "==0.2.6" diff --git a/vendor/github.com/testcontainers/testcontainers-go/Pipfile.lock b/vendor/github.com/testcontainers/testcontainers-go/Pipfile.lock index 9c8839c944..ff0b12f9d6 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/Pipfile.lock +++ b/vendor/github.com/testcontainers/testcontainers-go/Pipfile.lock @@ -1,7 +1,7 @@ { "_meta": { "hash": { - "sha256": "361ac26693514418dce9f92cca60528d549bd0b3f4710374cf77dafd399ae232" + "sha256": "c30436cdeb31baa333fdc82d0679532754a1ea51be468b4fd83da0de242b70cf" }, "pipfile-spec": 6, "requires": { @@ -140,11 +140,11 @@ }, "click": { "hashes": [ - "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", - "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4" + "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", + "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6" ], "markers": "python_version >= '3.10'", - "version": "==8.3.0" + "version": "==8.3.1" }, "colorama": { "hashes": [ @@ -187,11 +187,11 @@ }, "markdown": { "hashes": [ - "sha256:9f4d91ed810864ea88a6f32c07ba8bee1346c0cc1f6b1f9f6c822f2a9667d280", - "sha256:d2900fe1782bd33bdbbd56859defef70c2e78fc46668f8eb9df3128138f2cb6a" + "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", + "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36" ], - "markers": "python_version >= '3.9'", - "version": "==3.9" + "markers": "python_version >= '3.10'", + "version": "==3.10.2" }, "markupsafe": { "hashes": [ @@ -307,21 +307,21 @@ }, "mkdocs-codeinclude-plugin": { "hashes": [ - "sha256:172a917c9b257fa62850b669336151f85d3cd40312b2b52520cbcceab557ea6c", - "sha256:305387f67a885f0e36ec1cf977324fe1fe50d31301147194b63631d0864601b1" + "sha256:06bbbf0d4ac7eccaec6e0d89ce76d644a197cfed34880f541516e722ded6512a", + "sha256:443f32c9e4412b84ec084bd2b454020c5bf06cb9a958682e08a528e62b45da4d" ], "index": "pypi", - "markers": "python_version >= '3.7'", - "version": "==0.2.1" + "markers": "python_version >= '3.11'", + "version": "==0.3.1" }, "mkdocs-include-markdown-plugin": { "hashes": [ - "sha256:4a67a91ade680dc0e15f608e5b6343bec03372ffa112c40a4254c1bfb10f42f3", - "sha256:d56cdaeb2d113fb66ed0fe4fb7af1da889926b0b9872032be24e19bbb09c9f5b" + "sha256:30da634c568ea5d5f9e5881d51f80ac30d8c5f891cec160344ad7a0fdaea6286", + "sha256:5d94db87b06cd303619dbaebba5f7f43a3ded7fd7709451d26f08c176376ffec" ], "index": "pypi", "markers": "python_version >= '3.9'", - "version": "==7.2.0" + "version": "==7.2.1" }, "mkdocs-markdownextradata-plugin": { "hashes": [ @@ -351,11 +351,11 @@ }, "packaging": { "hashes": [ - "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", - "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f" + "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", + "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529" ], "markers": "python_version >= '3.8'", - "version": "==25.0" + "version": "==26.0" }, "paginate": { "hashes": [ @@ -365,35 +365,36 @@ }, "pathspec": { "hashes": [ - "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", - "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712" + "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", + "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723" ], - "markers": "python_version >= '3.8'", - "version": "==0.12.1" + "markers": "python_version >= '3.9'", + "version": "==1.0.4" }, "platformdirs": { "hashes": [ - "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", - "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3" + "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd", + "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291" ], "markers": "python_version >= '3.10'", - "version": "==4.5.0" + "version": "==4.9.2" }, "pygments": { "hashes": [ - "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c", - "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367" + "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", + "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b" ], - "markers": "python_version >= '3.7'", - "version": "==2.17.2" + "markers": "python_version >= '3.8'", + "version": "==2.19.2" }, "pymdown-extensions": { "hashes": [ - "sha256:3ab1db5c9e21728dabf75192d71471f8e50f216627e9a1fa9535ecb0231b9940", - "sha256:f938326115884f48c6059c67377c46cf631c733ef3629b6eed1349989d1b30cb" + "sha256:aace82bcccba3efc03e25d584e6a22d27a8e17caa3f4dd9f207e49b787aa9a91", + "sha256:d6ba157a6c03146a7fb122b2b9a121300056384eafeec9c9f9e584adfdb2a32d" ], - "markers": "python_version >= '3.8'", - "version": "==10.8.1" + "index": "pypi", + "markers": "python_version >= '3.9'", + "version": "==10.16.1" }, "python-dateutil": { "hashes": [ @@ -602,11 +603,12 @@ }, "urllib3": { "hashes": [ - "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", - "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc" + "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", + "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4" ], + "index": "pypi", "markers": "python_version >= '3.9'", - "version": "==2.5.0" + "version": "==2.6.3" }, "watchdog": { "hashes": [ diff --git a/vendor/github.com/testcontainers/testcontainers-go/commons-test.mk b/vendor/github.com/testcontainers/testcontainers-go/commons-test.mk index 10adfad8d4..bb86a9fab4 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/commons-test.mk +++ b/vendor/github.com/testcontainers/testcontainers-go/commons-test.mk @@ -6,7 +6,7 @@ define go_install endef $(GOBIN)/golangci-lint: - $(call go_install,github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.0.2) + $(call go_install,github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.9.0) $(GOBIN)/gotestsum: $(call go_install,gotest.tools/gotestsum@latest) diff --git a/vendor/github.com/testcontainers/testcontainers-go/container.go b/vendor/github.com/testcontainers/testcontainers-go/container.go index b0f2273a30..49c421a7d0 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/container.go +++ b/vendor/github.com/testcontainers/testcontainers-go/container.go @@ -28,8 +28,9 @@ import ( "github.com/testcontainers/testcontainers-go/wait" ) +// Deprecated: Use [Container] +// // DeprecatedContainer shows methods that were supported before, but are now deprecated -// Deprecated: Use Container type DeprecatedContainer interface { GetHostEndpoint(ctx context.Context, port string) (string, string, error) GetIPAddress(ctx context.Context) (string, error) diff --git a/vendor/github.com/testcontainers/testcontainers-go/docker.go b/vendor/github.com/testcontainers/testcontainers-go/docker.go index 9a2421485b..9cfe50fcc3 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/docker.go +++ b/vendor/github.com/testcontainers/testcontainers-go/docker.go @@ -54,7 +54,7 @@ const ( var ( // createContainerFailDueToNameConflictRegex is a regular expression that matches the container is already in use error. - createContainerFailDueToNameConflictRegex = regexp.MustCompile("Conflict. The container name .* is already in use by container .*") + createContainerFailDueToNameConflictRegex = regexp.MustCompile("[Tt]he container name .* is already in use by .*") // minLogProductionTimeout is the minimum log production timeout. minLogProductionTimeout = time.Duration(5 * time.Second) diff --git a/vendor/github.com/testcontainers/testcontainers-go/docker_auth.go b/vendor/github.com/testcontainers/testcontainers-go/docker_auth.go index 58b3ef2637..6472a9738e 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/docker_auth.go +++ b/vendor/github.com/testcontainers/testcontainers-go/docker_auth.go @@ -10,6 +10,7 @@ import ( "fmt" "net/url" "os" + "strings" "sync" "github.com/cpuguy83/dockercfg" @@ -42,6 +43,13 @@ func dockerImageAuth(ctx context.Context, image string, configs map[string]regis defaultRegistry := defaultRegistryFn(ctx) reg := core.ExtractRegistry(image, defaultRegistry) + // Normalize Docker Hub aliases for credential lookup + if strings.EqualFold(reg, "docker.io") || + strings.EqualFold(reg, "registry.hub.docker.com") || + strings.EqualFold(reg, "registry-1.docker.io") { + reg = defaultRegistry // This is https://index.docker.io/v1/ + } + if cfg, ok := getRegistryAuth(reg, configs); ok { return reg, cfg, nil } diff --git a/vendor/github.com/testcontainers/testcontainers-go/docker_client.go b/vendor/github.com/testcontainers/testcontainers-go/docker_client.go index e9eea1efeb..ea6522406e 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/docker_client.go +++ b/vendor/github.com/testcontainers/testcontainers-go/docker_client.go @@ -3,6 +3,7 @@ package testcontainers import ( "context" "fmt" + "strings" "sync" "github.com/docker/docker/api/types" @@ -69,9 +70,11 @@ func (c *DockerClient) Info(ctx context.Context) (system.Info, error) { if len(dockerInfo.Labels) > 0 { infoLabels = ` Labels:` + var infoLabelsSb72 strings.Builder for _, lb := range dockerInfo.Labels { - infoLabels += "\n " + lb + infoLabelsSb72.WriteString("\n " + lb) } + infoLabels += infoLabelsSb72.String() } log.Printf(infoMessage, packagePath, diff --git a/vendor/github.com/testcontainers/testcontainers-go/internal/core/images.go b/vendor/github.com/testcontainers/testcontainers-go/internal/core/images.go index e00160262f..90793f3fc4 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/internal/core/images.go +++ b/vendor/github.com/testcontainers/testcontainers-go/internal/core/images.go @@ -100,6 +100,16 @@ func ExtractRegistry(image string, fallback string) string { registry := exp[1] + // docker.io is an implicit reference, return fallback for normalization + if strings.EqualFold(registry, "docker.io") { + return fallback + } + + // registry.hub.docker.com is an explicit registry reference, preserve it + if strings.EqualFold(registry, "registry.hub.docker.com") { + return "registry.hub.docker.com" + } + if IsURL(registry) { return registry } diff --git a/vendor/github.com/testcontainers/testcontainers-go/internal/version.go b/vendor/github.com/testcontainers/testcontainers-go/internal/version.go index 4251b85b90..295c1a6a77 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/internal/version.go +++ b/vendor/github.com/testcontainers/testcontainers-go/internal/version.go @@ -1,4 +1,4 @@ package internal // Version is the next development version of the application -const Version = "0.40.0" +const Version = "0.41.0" diff --git a/vendor/github.com/testcontainers/testcontainers-go/mkdocs.yml b/vendor/github.com/testcontainers/testcontainers-go/mkdocs.yml index ac77b5b3bc..e4e13b8093 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/mkdocs.yml +++ b/vendor/github.com/testcontainers/testcontainers-go/mkdocs.yml @@ -19,6 +19,12 @@ theme: extra_css: - css/extra.css - css/tc-header.css + - css/usage-metrics.css +extra_javascript: + - https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js + - https://cdn.jsdelivr.net/npm/chartjs-adapter-date-fns@3.0.0/dist/chartjs-adapter-date-fns.bundle.min.js + - https://cdn.jsdelivr.net/npm/papaparse@5.4.1/papaparse.min.js + - js/usage-metrics.js repo_name: testcontainers-go repo_url: https://github.com/testcontainers/testcontainers-go markdown_extensions: @@ -86,6 +92,7 @@ nav: - modules/dynamodb.md - modules/elasticsearch.md - modules/etcd.md + - modules/forgejo.md - modules/gcloud.md - modules/grafana-lgtm.md - modules/inbucket.md @@ -123,6 +130,7 @@ nav: - modules/socat.md - modules/solace.md - modules/surrealdb.md + - modules/tidb.md - modules/toxiproxy.md - modules/valkey.md - modules/vault.md @@ -148,9 +156,10 @@ nav: - system_requirements/using_colima.md - system_requirements/using_podman.md - system_requirements/rancher.md + - Usage Metrics: usage-metrics.md - Dependabot: dependabot.md - Contributing: contributing.md - Getting help: getting_help.md edit_uri: edit/main/docs/ extra: - latest_version: v0.40.0 + latest_version: v0.41.0 diff --git a/vendor/github.com/testcontainers/testcontainers-go/options.go b/vendor/github.com/testcontainers/testcontainers-go/options.go index 007eaa774e..6e5f455d87 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/options.go +++ b/vendor/github.com/testcontainers/testcontainers-go/options.go @@ -343,7 +343,7 @@ func WithStartupCommand(execs ...Executable) CustomizeRequestOption { // is ready. func WithAfterReadyCommand(execs ...Executable) CustomizeRequestOption { return func(req *GenericContainerRequest) error { - postReadiesHook := []ContainerHook{} + postReadiesHook := make([]ContainerHook, 0, len(execs)) for _, exec := range execs { execFn := func(ctx context.Context, c Container) error { diff --git a/vendor/github.com/testcontainers/testcontainers-go/port_forwarding.go b/vendor/github.com/testcontainers/testcontainers-go/port_forwarding.go index 9d4ec10f9a..6a3c623864 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/port_forwarding.go +++ b/vendor/github.com/testcontainers/testcontainers-go/port_forwarding.go @@ -177,12 +177,12 @@ func exposeHostPorts(ctx context.Context, req *ContainerRequest, ports ...int) ( // newSshdContainer creates a new SSHD container with the provided options. func newSshdContainer(ctx context.Context, opts ...ContainerCustomizer) (*sshdContainer, error) { - moduleOpts := []ContainerCustomizer{ + moduleOpts := make([]ContainerCustomizer, 0, 3+len(opts)) + moduleOpts = append(moduleOpts, WithExposedPorts(sshPort), WithEnv(map[string]string{"PASSWORD": sshPassword}), WithWaitStrategy(wait.ForListeningPort(sshPort)), - } - + ) moduleOpts = append(moduleOpts, opts...) c, err := Run(ctx, sshdImage, moduleOpts...) diff --git a/vendor/github.com/testcontainers/testcontainers-go/reaper.go b/vendor/github.com/testcontainers/testcontainers-go/reaper.go index 4e46f0e381..4f5c555e56 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/reaper.go +++ b/vendor/github.com/testcontainers/testcontainers-go/reaper.go @@ -64,10 +64,11 @@ type ReaperProvider interface { Config() TestcontainersConfig } -// NewReaper creates a Reaper with a sessionID to identify containers and a provider to use // Deprecated: it's not possible to create a reaper any more. Compose module uses this method // to create a reaper for the compose stack. // +// # NewReaper creates a Reaper with a sessionID to identify containers and a provider to use +// // The caller must call Connect at least once on the returned Reaper and use the returned // result otherwise the reaper will be kept open until the process exits. func NewReaper(ctx context.Context, sessionID string, provider ReaperProvider, _ string) (*Reaper, error) { @@ -568,8 +569,9 @@ func (r *Reaper) handshake(conn net.Conn) error { return nil } -// Labels returns the container labels to use so that this Reaper cleans them up // Deprecated: internally replaced by core.DefaultLabels(sessionID) +// +// Labels returns the container labels to use so that this Reaper cleans them up func (r *Reaper) Labels() map[string]string { return GenericLabels() } diff --git a/vendor/github.com/testcontainers/testcontainers-go/requirements.txt b/vendor/github.com/testcontainers/testcontainers-go/requirements.txt index 861bf7492c..eb23d2ba03 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/requirements.txt +++ b/vendor/github.com/testcontainers/testcontainers-go/requirements.txt @@ -1,5 +1,5 @@ mkdocs==1.5.3 -mkdocs-codeinclude-plugin==0.2.1 -mkdocs-include-markdown-plugin==7.2.0 +mkdocs-codeinclude-plugin==0.3.1 +mkdocs-include-markdown-plugin==7.2.1 mkdocs-material==9.5.18 mkdocs-markdownextradata-plugin==0.2.6 diff --git a/vendor/github.com/testcontainers/testcontainers-go/wait/errors.go b/vendor/github.com/testcontainers/testcontainers-go/wait/errors.go index 3e3919a6fe..1b8cc946d5 100644 --- a/vendor/github.com/testcontainers/testcontainers-go/wait/errors.go +++ b/vendor/github.com/testcontainers/testcontainers-go/wait/errors.go @@ -1,5 +1,4 @@ //go:build !windows -// +build !windows package wait diff --git a/vendor/github.com/tklauser/go-sysconf/.cirrus.yml b/vendor/github.com/tklauser/go-sysconf/.cirrus.yml index 33e6595cca..61724abecb 100644 --- a/vendor/github.com/tklauser/go-sysconf/.cirrus.yml +++ b/vendor/github.com/tklauser/go-sysconf/.cirrus.yml @@ -1,10 +1,10 @@ env: CIRRUS_CLONE_DEPTH: 1 - GO_VERSION: go1.22.2 + GO_VERSION: go1.25.0 freebsd_13_task: freebsd_instance: - image_family: freebsd-13-2 + image_family: freebsd-13-5 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest @@ -14,7 +14,7 @@ freebsd_13_task: freebsd_14_task: freebsd_instance: - image_family: freebsd-14-0 + image_family: freebsd-14-2 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go b/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go index 40f6c345fc..87cf6a10a4 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go @@ -25,10 +25,13 @@ const ( _POSIX2_UPE = -1 ) -var clktck struct { - sync.Once - v int64 -} +var clktck = sync.OnceValue(func() int64 { + ci, err := unix.SysctlClockinfo("kern.clockrate") + if err != nil { + return -1 + } + return int64(ci.Hz) +}) func sysconfPOSIX(name int) (int64, error) { // NetBSD does not define all _POSIX_* values used in sysconf_posix.go @@ -54,14 +57,7 @@ func sysconf(name int) (int64, error) { } return -1, nil case SC_CLK_TCK: - // TODO: use sync.OnceValue once Go 1.21 is the minimal supported version - clktck.Do(func() { - clktck.v = -1 - if ci, err := unix.SysctlClockinfo("kern.clockrate"); err == nil { - clktck.v = int64(ci.Hz) - } - }) - return clktck.v, nil + return clktck(), nil case SC_NGROUPS_MAX: return sysctl32("kern.ngroups"), nil case SC_JOB_CONTROL: diff --git a/vendor/github.com/tklauser/numcpus/.cirrus.yml b/vendor/github.com/tklauser/numcpus/.cirrus.yml index 33e6595cca..61724abecb 100644 --- a/vendor/github.com/tklauser/numcpus/.cirrus.yml +++ b/vendor/github.com/tklauser/numcpus/.cirrus.yml @@ -1,10 +1,10 @@ env: CIRRUS_CLONE_DEPTH: 1 - GO_VERSION: go1.22.2 + GO_VERSION: go1.25.0 freebsd_13_task: freebsd_instance: - image_family: freebsd-13-2 + image_family: freebsd-13-5 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest @@ -14,7 +14,7 @@ freebsd_13_task: freebsd_14_task: freebsd_instance: - image_family: freebsd-14-0 + image_family: freebsd-14-2 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest diff --git a/vendor/github.com/tklauser/numcpus/numcpus.go b/vendor/github.com/tklauser/numcpus/numcpus.go index af59983e7d..de206f0612 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus.go +++ b/vendor/github.com/tklauser/numcpus/numcpus.go @@ -73,3 +73,26 @@ func GetPossible() (int, error) { func GetPresent() (int, error) { return getPresent() } + +// ListOffline returns the list of offline CPUs. See [GetOffline] for details on +// when a CPU is considered offline. +func ListOffline() ([]int, error) { + return listOffline() +} + +// ListOnline returns the list of CPUs that are online and being scheduled. +func ListOnline() ([]int, error) { + return listOnline() +} + +// ListPossible returns the list of possible CPUs. See [GetPossible] for +// details on when a CPU is considered possible. +func ListPossible() ([]int, error) { + return listPossible() +} + +// ListPresent returns the list of present CPUs. See [GetPresent] for +// details on when a CPU is considered present. +func ListPresent() ([]int, error) { + return listPresent() +} diff --git a/vendor/github.com/tklauser/numcpus/numcpus_linux.go b/vendor/github.com/tklauser/numcpus/numcpus_linux.go index 7e75cb0616..d05ee98253 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus_linux.go +++ b/vendor/github.com/tklauser/numcpus/numcpus_linux.go @@ -15,6 +15,7 @@ package numcpus import ( + "fmt" "os" "path/filepath" "strconv" @@ -23,7 +24,14 @@ import ( "golang.org/x/sys/unix" ) -const sysfsCPUBasePath = "/sys/devices/system/cpu" +const ( + sysfsCPUBasePath = "/sys/devices/system/cpu" + + offline = "offline" + online = "online" + possible = "possible" + present = "present" +) func getFromCPUAffinity() (int, error) { var cpuSet unix.CPUSet @@ -33,19 +41,28 @@ func getFromCPUAffinity() (int, error) { return cpuSet.Count(), nil } -func readCPURange(file string) (int, error) { +func readCPURangeWith[T any](file string, f func(cpus string) (T, error)) (T, error) { + var zero T buf, err := os.ReadFile(filepath.Join(sysfsCPUBasePath, file)) if err != nil { - return 0, err + return zero, err } - return parseCPURange(strings.Trim(string(buf), "\n ")) + return f(string(buf)) } -func parseCPURange(cpus string) (int, error) { +func countCPURange(cpus string) (int, error) { + cpus = strings.Trim(cpus, "\n ") + + // Treat empty file as valid. This might be the case if there are no offline CPUs in which + // case /sys/devices/system/cpu/offline is empty. + if cpus == "" { + return 0, nil + } + n := int(0) - for _, cpuRange := range strings.Split(cpus, ",") { - if len(cpuRange) == 0 { - continue + for cpuRange := range strings.SplitSeq(cpus, ",") { + if cpuRange == "" { + return 0, fmt.Errorf("empty CPU range in CPU string %q", cpus) } from, to, found := strings.Cut(cpuRange, "-") first, err := strconv.ParseUint(from, 10, 32) @@ -60,11 +77,51 @@ func parseCPURange(cpus string) (int, error) { if err != nil { return 0, err } + if last < first { + return 0, fmt.Errorf("last CPU in range (%d) less than first (%d)", last, first) + } n += int(last - first + 1) } return n, nil } +func listCPURange(cpus string) ([]int, error) { + cpus = strings.Trim(cpus, "\n ") + + // See comment in countCPURange. + if cpus == "" { + return []int{}, nil + } + + list := []int{} + for cpuRange := range strings.SplitSeq(cpus, ",") { + if cpuRange == "" { + return nil, fmt.Errorf("empty CPU range in CPU string %q", cpus) + } + from, to, found := strings.Cut(cpuRange, "-") + first, err := strconv.ParseUint(from, 10, 32) + if err != nil { + return nil, err + } + if !found { + // range containing a single element + list = append(list, int(first)) + continue + } + last, err := strconv.ParseUint(to, 10, 32) + if err != nil { + return nil, err + } + if last < first { + return nil, fmt.Errorf("last CPU in range (%d) less than first (%d)", last, first) + } + for cpu := int(first); cpu <= int(last); cpu++ { + list = append(list, cpu) + } + } + return list, nil +} + func getConfigured() (int, error) { d, err := os.Open(sysfsCPUBasePath) if err != nil { @@ -100,20 +157,36 @@ func getKernelMax() (int, error) { } func getOffline() (int, error) { - return readCPURange("offline") + return readCPURangeWith(offline, countCPURange) } func getOnline() (int, error) { if n, err := getFromCPUAffinity(); err == nil { return n, nil } - return readCPURange("online") + return readCPURangeWith(online, countCPURange) } func getPossible() (int, error) { - return readCPURange("possible") + return readCPURangeWith(possible, countCPURange) } func getPresent() (int, error) { - return readCPURange("present") + return readCPURangeWith(present, countCPURange) +} + +func listOffline() ([]int, error) { + return readCPURangeWith(offline, listCPURange) +} + +func listOnline() ([]int, error) { + return readCPURangeWith(online, listCPURange) +} + +func listPossible() ([]int, error) { + return readCPURangeWith(possible, listCPURange) +} + +func listPresent() ([]int, error) { + return readCPURangeWith(present, listCPURange) } diff --git a/vendor/github.com/tklauser/numcpus/numcpus_list_unsupported.go b/vendor/github.com/tklauser/numcpus/numcpus_list_unsupported.go new file mode 100644 index 0000000000..af4efeacf4 --- /dev/null +++ b/vendor/github.com/tklauser/numcpus/numcpus_list_unsupported.go @@ -0,0 +1,33 @@ +// Copyright 2024 Tobias Klauser +// +// 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. + +//go:build !linux + +package numcpus + +func listOffline() ([]int, error) { + return nil, ErrNotSupported +} + +func listOnline() ([]int, error) { + return nil, ErrNotSupported +} + +func listPossible() ([]int, error) { + return nil, ErrNotSupported +} + +func listPresent() ([]int, error) { + return nil, ErrNotSupported +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 64d63cda34..22c3dc204e 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -8,7 +8,7 @@ dario.cat/mergo ## explicit; go 1.20 filippo.io/edwards25519 filippo.io/edwards25519/field -# github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 +# github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c ## explicit; go 1.16 github.com/Azure/go-ansiterm github.com/Azure/go-ansiterm/winterm @@ -391,7 +391,7 @@ github.com/distribution/reference ## explicit github.com/dlclark/regexp2 github.com/dlclark/regexp2/syntax -# github.com/docker/docker v28.5.1+incompatible +# github.com/docker/docker v28.5.2+incompatible ## explicit github.com/docker/docker/api github.com/docker/docker/api/types @@ -431,12 +431,13 @@ github.com/dustin/go-humanize # github.com/dutchcoders/go-clamd v0.0.0-20170520113014-b970184f4d9e ## explicit github.com/dutchcoders/go-clamd -# github.com/ebitengine/purego v0.8.4 +# github.com/ebitengine/purego v0.10.0 ## explicit; go 1.18 github.com/ebitengine/purego github.com/ebitengine/purego/internal/cgo github.com/ebitengine/purego/internal/fakecgo github.com/ebitengine/purego/internal/strings +github.com/ebitengine/purego/internal/xreflect # github.com/egirna/icap v0.0.0-20181108071049-d5ee18bd70bc ## explicit github.com/egirna/icap @@ -1120,7 +1121,7 @@ github.com/mna/pigeon/builder # github.com/moby/docker-image-spec v1.3.1 ## explicit; go 1.18 github.com/moby/docker-image-spec/specs-go/v1 -# github.com/moby/go-archive v0.1.0 +# github.com/moby/go-archive v0.2.0 ## explicit; go 1.23.0 github.com/moby/go-archive github.com/moby/go-archive/compression @@ -1138,7 +1139,7 @@ github.com/moby/sys/user # github.com/moby/sys/userns v0.1.0 ## explicit; go 1.21 github.com/moby/sys/userns -# github.com/moby/term v0.5.0 +# github.com/moby/term v0.5.2 ## explicit; go 1.18 github.com/moby/term github.com/moby/term/windows @@ -1834,7 +1835,7 @@ github.com/pkg/xattr # github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 ## explicit github.com/pmezard/go-difflib/difflib -# github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c +# github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 ## explicit; go 1.14 github.com/power-devops/perfstat # github.com/pquerna/cachecontrol v0.2.0 @@ -2022,8 +2023,8 @@ github.com/shamaton/msgpack/v2/internal/encoding github.com/shamaton/msgpack/v2/internal/stream/decoding github.com/shamaton/msgpack/v2/internal/stream/encoding github.com/shamaton/msgpack/v2/time -# github.com/shirou/gopsutil/v4 v4.25.6 -## explicit; go 1.23 +# github.com/shirou/gopsutil/v4 v4.26.2 +## explicit; go 1.24.0 github.com/shirou/gopsutil/v4/common github.com/shirou/gopsutil/v4/cpu github.com/shirou/gopsutil/v4/internal/common @@ -2097,8 +2098,8 @@ github.com/tchap/go-patricia/v2/patricia ## explicit github.com/test-go/testify/mock github.com/test-go/testify/require -# github.com/testcontainers/testcontainers-go v0.40.0 -## explicit; go 1.24.0 +# github.com/testcontainers/testcontainers-go v0.41.0 +## explicit; go 1.25.0 github.com/testcontainers/testcontainers-go github.com/testcontainers/testcontainers-go/exec github.com/testcontainers/testcontainers-go/internal @@ -2132,11 +2133,11 @@ github.com/tidwall/sjson ## explicit; go 1.24 github.com/tinylib/msgp/msgp github.com/tinylib/msgp/msgp/setof -# github.com/tklauser/go-sysconf v0.3.14 -## explicit; go 1.18 +# github.com/tklauser/go-sysconf v0.3.16 +## explicit; go 1.24.0 github.com/tklauser/go-sysconf -# github.com/tklauser/numcpus v0.8.0 -## explicit; go 1.18 +# github.com/tklauser/numcpus v0.11.0 +## explicit; go 1.24.0 github.com/tklauser/numcpus # github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208 ## explicit