diff --git a/go.mod b/go.mod index 0ed63982c..13cd59ee7 100644 --- a/go.mod +++ b/go.mod @@ -47,7 +47,7 @@ require ( github.com/swaggo/files v1.0.1 github.com/swaggo/gin-swagger v1.6.1 github.com/swaggo/swag v1.16.6 - github.com/testcontainers/testcontainers-go v0.40.0 + github.com/testcontainers/testcontainers-go v0.41.0 github.com/xuri/excelize/v2 v2.10.1 go.mongodb.org/mongo-driver/v2 v2.5.0 go.opentelemetry.io/contrib/propagators/jaeger v1.42.0 @@ -68,7 +68,7 @@ require ( require ( dario.cat/mergo v1.0.2 // 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/KyleBanks/depth v1.2.1 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/PaesslerAG/gval v1.2.4 // indirect @@ -88,12 +88,12 @@ require ( github.com/cpuguy83/dockercfg v0.3.2 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/distribution/reference v0.6.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/eapache/go-resiliency v1.7.0 // indirect github.com/eapache/queue v1.1.0 // indirect - github.com/ebitengine/purego v0.8.4 // indirect + github.com/ebitengine/purego v0.10.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/gabriel-vasile/mimetype v1.4.13 // indirect github.com/gin-contrib/sse v1.1.0 // indirect @@ -145,12 +145,12 @@ require ( github.com/mattermost/xml-roundtrip-validator v0.1.0 // indirect github.com/mattn/go-isatty v0.0.20 // 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.2 // indirect github.com/morikuni/aec v1.0.0 // indirect @@ -164,7 +164,7 @@ require ( github.com/pierrec/lz4/v4 v4.1.26 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // 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/client_golang v1.23.2 // indirect github.com/prometheus/client_model v0.6.2 // indirect @@ -176,13 +176,13 @@ require ( github.com/richardlehane/mscfb v1.0.6 // indirect github.com/richardlehane/msoleps v1.0.6 // indirect github.com/segmentio/asm v1.2.1 // indirect - github.com/shirou/gopsutil/v4 v4.25.6 // indirect + github.com/shirou/gopsutil/v4 v4.26.2 // indirect github.com/shopspring/decimal v1.4.0 // indirect github.com/sirosfoundation/g119612 v0.0.0-20260108094825-5b3123230280 // indirect github.com/sirupsen/logrus v1.9.3 // indirect github.com/tiendc/go-deepcopy v1.7.2 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect + github.com/tklauser/go-sysconf v0.3.16 // indirect + github.com/tklauser/numcpus v0.11.0 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/ugorji/go/codec v1.3.1 // indirect github.com/valyala/fastjson v1.6.10 // indirect diff --git a/go.sum b/go.sum index 4480e64c4..065c2ccf5 100644 --- a/go.sum +++ b/go.sum @@ -4,8 +4,8 @@ filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= 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/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/IBM/sarama v1.47.0 h1:GcQFEd12+KzfPYeLgN69Fh7vLCtYRhVIx0rO4TZO318= github.com/IBM/sarama v1.47.0/go.mod h1:7gLLIU97nznOmA6TX++Qds+DRxH89P2XICY2KAQUzAY= github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc= @@ -69,8 +69,8 @@ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1 h1:5RVFMOWjMyRy8cARdy79nAmgYw3h github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= -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= @@ -81,8 +81,8 @@ github.com/eapache/go-resiliency v1.7.0 h1:n3NRTnBn5N0Cbi/IeOHuQn9s2UwVUH7Ga0ZWc github.com/eapache/go-resiliency v1.7.0/go.mod h1:5yPzW0MIvSe0JDsv0v+DvcjEv2FyD6iZYSs1ZI+iQho= github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc= 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/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= @@ -256,8 +256,8 @@ github.com/miekg/pkcs11 v1.1.2 h1:/VxmeAX5qU6Q3EwafypogwWbYryHFmF2RpkJmw3m4MQ= github.com/miekg/pkcs11 v1.1.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs= 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= @@ -268,8 +268,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= @@ -305,8 +305,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -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/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= @@ -333,8 +333,8 @@ github.com/russellhaering/goxmldsig v1.6.0 h1:8fdWXEPh2k/NZNQBPFNoVfS3JmzS4ZprY/ github.com/russellhaering/goxmldsig v1.6.0/go.mod h1:TrnaquDcYxWXfJrOjeMBTX4mLBeYAqaHEyUeWPxZlBM= github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0= github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= -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/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= @@ -370,14 +370,14 @@ github.com/swaggo/gin-swagger v1.6.1 h1:Ri06G4gc9N4t4k8hekMigJ9zKTFSlqj/9paAQCQs github.com/swaggo/gin-swagger v1.6.1/go.mod h1:LQ+hJStHakCWRiK/YNYtJOu4mR2FP+pxLnILT/qNiTw= github.com/swaggo/swag v1.16.6 h1:qBNcx53ZaX+M5dxVyTrgQ0PJ/ACK+NzhwcbieTt+9yI= github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4Xesg= -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/tiendc/go-deepcopy v1.7.2 h1:Ut2yYR7W9tWjTQitganoIue4UGxZwCcJy3orjrrIj44= github.com/tiendc/go-deepcopy v1.7.2/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +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/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY= @@ -476,8 +476,6 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= 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 000000000..e138ec5d6 --- /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 593b10ab6..194d5e9c9 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 6ca2c2b08..feb42e808 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 f1ff9053a..8fb85c2ca 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 +### Tier 1 + +Tier 1 platforms are the primary targets officially supported by PureGo. When a new version of PureGo is released, any critical bugs found on Tier 1 platforms are treated as release blockers. The release will be postponed until such issues are resolved. + +- **Android**: amd641, arm641 +- **iOS**: amd641, arm641 - **Linux**: amd64, arm64 -- **macOS / iOS**: amd64, arm64 -- **Windows**: 386*, amd64, arm*, 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. -`*` These architectures only support SyscallN and NewCallback +- **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 000000000..b10d83732 --- /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 7d5abef34..b6def570c 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 95cdfe16f..ad52b436c 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 cd1bf293c..2730d82cd 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 27f560715..5dd44468d 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 000000000..220c73676 --- /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") + // 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) { - 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 - } - } 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 000000000..9cb7c4535 --- /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 13671ff23..b327f7869 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 b09ecac1c..6d0571abb 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 37ff24d5c..1e39de3b6 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 000000000..b10d83732 --- /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 000000000..245a5266f --- /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 000000000..7475ec8a0 --- /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 000000000..68034e603 --- /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 000000000..e81df86a5 --- /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 000000000..6d1938cd8 --- /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 000000000..acf82c1b5 --- /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 000000000..b64466501 --- /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 f29e690cc..27d4c98c8 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 be82f7dfc..e482c120c 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 000000000..384dab2a6 --- /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 39f5ff1f0..000000000 --- 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 e3a060b93..a3ba6bc82 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 e5a66f39d..0c4630669 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 a3b1cca59..9f380c1b4 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 c9ff7156a..000000000 --- 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 c9ff7156a..935a334f2 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 e42d84f0b..dfc6629e4 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 0ac10d1f1..ee993baae 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 28af41cc6..12e521470 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 38f944193..94fd8beab 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 af148333f..ecdcb2e78 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 ca1f722c9..4bfb70c3d 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 c4b6e9ea5..b08a44a10 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 000000000..650f6953e --- /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 000000000..2d499814f --- /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 f30af0e15..82308b8ca 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 000000000..cd3492ea7 --- /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 c9a3cc09e..e4e4c75a3 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 000000000..00b3177ef --- /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 9dbdbc013..dceb1cac6 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 000000000..7596f0da1 --- /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 000000000..85f895564 --- /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 000000000..9298f8c71 --- /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 d51702400..cc552e7d3 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 54aaa4628..960f8168e 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 815381197..d69775596 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 180057d01..f6bad22c3 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 000000000..774402cfb --- /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 000000000..35ef7ac11 --- /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 000000000..da07005c0 --- /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 000000000..da07005c0 --- /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 000000000..81ef76f59 --- /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 a65b2012c..8e1afff73 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 000000000..5eb0580e0 --- /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 000000000..62ee13d6c --- /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 5b989ea81..b91b9796b 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 000000000..02c8ac45c --- /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 f3514c984..c56f957af 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 000000000..1b580585d --- /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 11c36bd6e..5f347c83d 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 000000000..e5891401c --- /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 9d42adac8..000000000 --- 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 000000000..7c50dcbba --- /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 000000000..eac0b8802 --- /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 000000000..7ec5e813c --- /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 000000000..82931413e --- /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 cabde1a58..15b24dd29 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 000000000..3a8ce0d0d --- /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 a68fdb99b..40a2f4c1d 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 000000000..420b855c2 --- /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 000000000..391b30a95 --- /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 000000000..e7e887e15 --- /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 000000000..a044e34d3 --- /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 000000000..31aecbf3c --- /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 000000000..a97e9437d --- /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 6da06b4d1..cea803ef9 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 000000000..cd00f9c1a --- /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 000000000..37f0d8d60 --- /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 000000000..8341d5b08 --- /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 000000000..9eed6d29c --- /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 c30688dda..7b45383d3 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 000000000..f9f376303 --- /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 36ee14e3b..179167f4b 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 cce171c8f..e35b32e71 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 000000000..d4f6c7b7f --- /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 000000000..87ed98111 --- /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 5fbfcabfd..5afd8d83c 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 000000000..bd2d9c85a --- /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 6a778bfca..b2da02255 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 000000000..d969d81d0 --- /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 c079b8038..3fea4af8b 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 000000000..c5dcd48e5 --- /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 000000000..702243b1e --- /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 000000000..f341a87ee --- /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 000000000..6b5e2b038 --- /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/kaptinlin/go-i18n/LICENSE b/vendor/github.com/kaptinlin/go-i18n/LICENSE index 8627d066c..dc7cb2a08 100644 --- a/vendor/github.com/kaptinlin/go-i18n/LICENSE +++ b/vendor/github.com/kaptinlin/go-i18n/LICENSE @@ -1,21 +1,21 @@ -MIT License - -Copyright (c) 2026 kaptinlin - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +MIT License + +Copyright (c) 2026 kaptinlin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/kaptinlin/go-i18n/README.md b/vendor/github.com/kaptinlin/go-i18n/README.md index d22416f2d..87a64a828 100644 --- a/vendor/github.com/kaptinlin/go-i18n/README.md +++ b/vendor/github.com/kaptinlin/go-i18n/README.md @@ -1,655 +1,655 @@ -# i18n (Go) - -`kaptinlin/go-i18n` is a high-performance, modern localization and internationalization library for Go. - -## Features - -- **Token-based** (`hello_world`) and **Text-based** (`Hello, world!`) translation -- **High Performance**: Optimized with Go 1.26 features (slices, maps, built-in functions) -- **ICU MessageFormat v1**: Full support with [kaptinlin/messageformat-go](https://github.com/kaptinlin/messageformat-go) -- **Flexible Loading**: From maps, files, glob patterns, or `go:embed` -- **Smart Fallbacks**: Recursive fallback chains with language confidence matching -- **Custom Formatters**: Extensible formatting system for complex use cases -- **Accept-Language**: Built-in HTTP header parsing support - -## Index -- [Installation](#installation) -- [Getting Started](#getting-started) -- [Advanced Configuration](#advanced-configuration) - - [Custom Formatters](#custom-formatters) - - [Strict Mode](#strict-mode) - - [MessageFormat Options](#messageformat-options) -- [Loading Methods](#loading-methods) - - [Load from Go map](#load-from-go-map) - - [Load from Files](#load-from-files) - - [Load from Glob Matching Files](#load-from-glob-matching-files) - - [Load from Embedded Files](#load-from-embedded-files) -- [Translations](#translations) - - [Passing Data to Translation](#passing-data-to-translation) - - [Direct Formatting](#direct-formatting) -- [Pluralization](#pluralization) -- [Text-based Translations](#text-based-translations) - - [Disambiguation by context](#disambiguation-by-context) - - [Act as fallback](#act-as-fallback) -- [Fallbacks](#fallbacks) -- [Custom Unmarshaler](#custom-unmarshaler) - - [YAML Unmarshaler](#yaml-unmarshaler) - - [TOML Unmarshaler](#toml-unmarshaler) - - [INI Unmarshaler](#ini-unmarshaler) -- [Parse Accept-Language](#parse-accept-language) -- [Performance](#performance) - -  - -## Installation - -```bash -$ go get github.com/kaptinlin/go-i18n@latest -``` - -  - -## Getting started - -Create a folder named `./locales` and put some `YAML`, `TOML`, `INI` or `JSON` files. - -```sh -│ main.go -└───locales - ├───en.json - └───zh-Hans.json -``` - -Now, put the key-values content for each locale, e.g. - -**locales/en.json** -```json -{ - "hello": "Hello, {name}" -} -``` - -**locales/zh-Hans.json** -```json -{ - "hello": "你好, {name}" -} -``` - -**main.go** - -```go -package main - -import ( - "github.com/kaptinlin/go-i18n" - "fmt" -) - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - ) - - err := bundle.LoadFiles("./locales/zh-Hans.json", "./locales/en.json") - if err != nil { - fmt.Println(err) - } - - localizer := bundle.NewLocalizer("zh-Hans") - - // Output: 你好, John - fmt.Println(localizer.Get("hello", i18n.Vars{ - "name": "John", - })) -} -``` - -  - -## Advanced Configuration - -### Custom Formatters - -Add custom formatters for domain-specific formatting needs: - -```go -bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithCustomFormatters(map[string]interface{}{ - "upper": func(value interface{}, locale string, arg *string) interface{} { - return strings.ToUpper(fmt.Sprintf("%v", value)) - }, - "currency": func(value interface{}, locale string, arg *string) interface{} { - // Custom currency formatting - return fmt.Sprintf("$%.2f", value) - }, - }), -) - -localizer := bundle.NewLocalizer("en") -result, _ := localizer.Format("Hello, {name, upper}!", i18n.Vars{ - "name": "world", -}) -// Output: Hello, WORLD! -``` - -### Strict Mode - -Enable strict parsing for better error detection: - -```go -bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithStrictMode(true), -) -``` - -### MessageFormat Options - -Configure MessageFormat behavior: - -```go -import mf "github.com/kaptinlin/messageformat-go/v1" - -options := &mf.MessageFormatOptions{ - Strict: true, - Currency: "USD", - // Add other MessageFormat options -} - -bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithMessageFormatOptions(options), -) -``` - -  - -## Loading Methods - -## Load from Go map - -```go -package main - -import "github.com/kaptinlin/go-i18n" - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - ) - - bundle.LoadMessages(map[string]map[string]string{ - "en": map[string]string{ - "hello_world": "hello, world", - }, - "zh-Hans": map[string]string{ - "hello_world": "你好，世界", - }, - }) -} -``` - -  - -## Load from Files - -```go -package main - -import "github.com/kaptinlin/go-i18n" - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - ) - - bundle.LoadFiles("./locales/en.json", "./locales/zh-Hans.json") -} -``` - -Filenames like `zh-Hans.json` `zh-Hans.user.json` will be combined to a single `zh-Hans` translation. - -No matter if you are naming them like `zh_CN`, `zh-Hans` or `ZH_CN`, they will always be converted to `zh-Hans`. - -  - -## Load from Glob Matching Files - -```go -package main - -import "github.com/kaptinlin/go-i18n" - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - ) - - bundle.LoadGlob("./locales/*.json") -} -``` - -The glob pattern adds all files within `locales` directory with the `.json` extension - -  - -## Load from Embedded Files - -Use `LoadFS` if you are using `go:embed` to compile your translations to the program. - -```go -package main - -import "github.com/kaptinlin/go-i18n" - -//go:embed locales/*.json -var localesFS embed.FS - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - ) - - // Load all json files under `locales` folder from the filesystem. - bundle.LoadFS(localesFS, "locales/*.json") -} -``` - -  - -## Translations - -Translations named like `welcome_message`, `button_create`, `button_buy` are token-based translations. For text-based, check the chapters below. - -```json -{ - "hello_world": "你好，世界" -} -``` - -```go -localizer := bundle.NewLocalizer("zh-Hans") - -// Output: 你好，世界 -localizer.Get("hello_world") - -// Output: message_what_is_this -localizer.Get("message_what_is_this") -``` - -Languages named like `zh_cn`, `zh-Hans` or `ZH_CN`, `NewLocalizer` will always convert them to `zh-Hans`. - -  - -### Passing Data to Translation - -It's possible to pass the data to translations. [ICU MessageFormat](https://unicode-org.github.io/icu/userguide/format_parse/messages/) is used to parse the text, the templates will be parsed and cached after the translation was loaded. - -```json -{ - "message_vars": "你好，{Name}" -} -``` - -```go -// Output: 你好，Yami -localizer.Get("message_vars", i18n.Vars{ - "Name": "Yami", -}) -``` - -### Direct Formatting - -Use the `Format` method to compile and format MessageFormat strings directly: - -```go -localizer := bundle.NewLocalizer("en") - -result, err := localizer.Format("Hello, {name}!", i18n.Vars{ - "name": "Alice", -}) -// Output: Hello, Alice! - -result, err = localizer.Format("{count, plural, =0 {no items} one {# item} other {# items}}", i18n.Vars{ - "count": 5, -}) -// Output: 5 items -``` - -  - -## Pluralization - -Using language specific plural forms (`one`, `other`) - -```json -{ - "message": "{count, plural, one {Message} other {Messages}}" -} -``` - -```go -// Output: Message -localizer.Get("message", i18n.Vars{ - "count": 1, -}) - -// Output: Messages -localizer.Get("message", i18n.Vars{ - "count": 2, -}) -``` - -Using exact matches (`=0`): -```json -{ - "messages": "{count, plural, =0 {No messages} one {1 message} other {# messages}}" -} -``` - -```go -// Output: No messages -localizer.Get("messages", i18n.Vars{ - "count": 0, -}) - -// Output: 1 message -localizer.Get("messages", i18n.Vars{ - "count": 1, -}) - -// Output: 2 messages -localizer.Get("messages", i18n.Vars{ - "count": 2, -}) -``` - -  - -## Text-based Translations - -Translations can also be named with sentences so it will act like fallbacks when the translation was not found. - -```json -{ - "I'm fine.": "我过得很好。", - "How about you?": "你如何呢？" -} -``` - -```go -// Output: 我过得很好。 -localizer.Get("I'm fine.") - -// Output: 你如何呢？ -localizer.Get("How about you?") - -// Output: Thank you! -localizer.Get("Thank you!") -``` - -  - -### Disambiguation by context - -In English a "Post" can be "Post something (verb)" or "A post (noun)". With token-based translation, you can easily separating them to `post_verb` and `post_noun`. - -With text-based translation, you will need to use `GetX` (X stands for context), and giving the translation a `` suffix. - -The space before the `<` is **REQUIRED**. - -```json -{ - "Post ": "发表文章", - "Post ": "一篇文章" -} -``` - -```go -// Output: 发表文章 -localizer.GetX("Post", "verb") - -// Output: 一篇文章 -localizer.GetX("Post", "noun") - -// Output: Post -localizer.GetX("Post", "adjective") -``` - -  - -### Act as fallback - -Remember, if a translation was not found, the token name will be output directly. The token name can also be used as template content. - -```go -// Output: Hello, World -localizer.Get("Hello, {Name}", i18n.Vars{ - "Name": "World", -}) - -// Output: 2 Posts -localizer.Get("{count, plural, =0 {No Post} one {1 Post} other {# Posts}}", i18n.Vars{ - "Count": 2, -}) -``` - -  - -## Fallbacks - -A fallback language will be used when a translation is missing from the current language. If it's still missing from the fallback language, it will lookup from the default language. - -If a translation cannot be found from any language, the token name will be output directly. - -```go -// `ja-jp` is the default language -bundle :=i18n.New( - i18n.WithDefaultLocale("ja-JP"), - i18n.WithFallback(map[string][]string{ - // `zh-Hans` uses `zh`, `zh-Hant` as fallbacks. - // `en-GB` uses `en-US` as fallback. - "zh-Hans": []string{"zh", "zh-Hant"}, - "en-GB": []string{"en-US"}, - }, -)) -``` - -Lookup path looks like this with the example above: - -``` -zh-Hans -> zh -> zh-Hant -> ja-JP -en-GB -> en-US -> ja-JP -``` - -Recursive fallback is also supported. If `zh-Hans` has a `zh` fallback, and `zh` has a `zh-Hant` fallback, `zh-Hans` will have either `zh` and `zh-Hant` fallbacks. - -Fallback only works if the translation exists in default language. - -  - -## Custom Unmarshaler - -Translations are JSON format by default using `github.com/go-json-experiment/json` as the default unmarshaler. Change it by calling `WithUnmarshaler`. - -### YAML Unmarshaler -Uses [`go-yaml/yaml`](https://github.com/go-yaml/yaml) to read the files, so you can write the translation files in YAML format. - -```go -package main - -import "gopkg.in/yaml.v3" - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - i18n.WithUnmarshaler(yaml.Unmarshal), - ) -} -``` - -Your `zh-Hans.yaml` should look like this: - -```yaml -hello_world: "你好，世界" -"How are you?": "你过得如何？" -"mobile_interface.button": "按钮" -``` - -Nested translations are not supported, you will need to name them like `"mobile_interface.button"` as key and quote them in double quotes. - -  - -### TOML Unmarshaler - -Uses [`pelletier/go-toml`](https://github.com/pelletier/go-toml) to read the files, so you can write the translation files in TOML format. - -```go -package main - -import "github.com/pelletier/go-toml/v2" - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - i18n.WithUnmarshaler(toml.Unmarshal), - ) -} -``` - -Your `zh-Hans.toml` should look like this: - -```toml -hello_world = "你好, 世界" -hello_name = "你好, {name}" -message = "{count, plural, one {消息} other {消息}}" -message_with_number = "{count, plural, =0 {没有消息} one {1 条消息} other {# 条消息}}" -``` - -  - -### INI Unmarshaler - -Uses [`go-ini/ini`](https://gopkg.in/ini.v1) to read the files, so you can write the translation files in INI format. - -```go -package main - -import "gopkg.in/ini.v1" - -func unmarshalINI(data []byte, v interface{}) error { - f, err := ini.LoadSources(ini.LoadOptions{ - SpaceBeforeInlineComment: true, - IgnoreInlineComment: true, - }, data) - if err != nil { - return err - } - - m := *v.(*map[string]string) - - for _, section := range f.Sections() { - keyPrefix := "" - if name := section.Name(); name != ini.DefaultSection { - keyPrefix = name + "." - } - - for _, key := range section.Keys() { - m[keyPrefix+key.Name()] = key.Value() - } - } - - return nil -} - -func main() { - bundle := i18n.NewBundle( - i18n.WithDefaultLocale("en"), - i18n.WithLocales("en", "zh-Hans"), - i18n.WithUnmarshaler(unmarshalINI), - ) -} -``` - -Your `zh-Hans.ini` should look like this: - -```ini -hello_world=你好, 世界 -hello_name=你好, {name} -message={count, plural, one {消息} other {消息}} - -[message] -with_number="{count, plural, =0 {没有消息} one {1 条消息} other {# 条消息}}" -``` - -  - -## Parse Accept-Language - -The built-in `MatchAvailableLocale` function helps you to parse the `Accept-Language` from HTTP Header. - -```go -func(w http.ResponseWriter, r *http.Request) { - // Initialize i18n. - bundle :=i18n.NewBundle( - i18n.WithDefaultLocale("zh-Hans"), - i18n.WithLocales("en", "zh-Hans"), - ) - bundle.LoadFiles("zh-Hans.json", "en.json") - - // Get `Accept-Language` from request header. - accept := r.Header.Get("Accept-Language") - - // Use the locale. - localizer := bundle.NewLocalizer(bundle.MatchAvailableLocale(accept)) - localizer.Get("hello_world") -} -``` - -Orders of the languages that passed to `NewLocalizer` won't affect the fallback priorities, it will use the first language that was found in loaded translations. - -  - -## Performance - -This library is optimized with Go 1.26 features for maximum performance: - -### Optimizations Applied - -- **Built-in Functions**: Uses `min()`, `max()`, and `clear()` for efficient operations -- **Slices Package**: Pre-allocation with `slices.Grow()`, deduplication with `slices.Compact()` -- **Maps Package**: Bulk copying with `maps.Copy()` instead of element-by-element assignment -- **String Processing**: `strings.Cut()` and `strings.Builder` for reduced memory allocations -- **Memory Pre-allocation**: Smart capacity estimation for slices and maps -- **Modern MessageFormat**: 10-50x performance improvement over previous engines - -### Benchmarks - -The modernized codebase shows significant improvements: -- **String normalization**: 40-60% faster with reduced allocations -- **File loading**: 25-35% faster with batch operations -- **Translation lookup**: Optimized with pre-allocated data structures -- **MessageFormat parsing**: 10-50x faster with new engine - -  - -## Thanks - -- https://github.com/teacat/i18n -- https://github.com/kataras/i18n -- https://github.com/nicksnyder/go-i18n -- https://github.com/vorlif/spreak -- https://github.com/oblq/i18n - -## License - -`kaptinlin/i18n` is free and open-source software licensed under the [MIT License](https://tldrlegal.com/license/mit-license). +# i18n (Go) + +`kaptinlin/go-i18n` is a high-performance, modern localization and internationalization library for Go. + +## Features + +- **Token-based** (`hello_world`) and **Text-based** (`Hello, world!`) translation +- **High Performance**: Optimized with Go 1.26 features (slices, maps, built-in functions) +- **ICU MessageFormat v1**: Full support with [kaptinlin/messageformat-go](https://github.com/kaptinlin/messageformat-go) +- **Flexible Loading**: From maps, files, glob patterns, or `go:embed` +- **Smart Fallbacks**: Recursive fallback chains with language confidence matching +- **Custom Formatters**: Extensible formatting system for complex use cases +- **Accept-Language**: Built-in HTTP header parsing support + +## Index +- [Installation](#installation) +- [Getting Started](#getting-started) +- [Advanced Configuration](#advanced-configuration) + - [Custom Formatters](#custom-formatters) + - [Strict Mode](#strict-mode) + - [MessageFormat Options](#messageformat-options) +- [Loading Methods](#loading-methods) + - [Load from Go map](#load-from-go-map) + - [Load from Files](#load-from-files) + - [Load from Glob Matching Files](#load-from-glob-matching-files) + - [Load from Embedded Files](#load-from-embedded-files) +- [Translations](#translations) + - [Passing Data to Translation](#passing-data-to-translation) + - [Direct Formatting](#direct-formatting) +- [Pluralization](#pluralization) +- [Text-based Translations](#text-based-translations) + - [Disambiguation by context](#disambiguation-by-context) + - [Act as fallback](#act-as-fallback) +- [Fallbacks](#fallbacks) +- [Custom Unmarshaler](#custom-unmarshaler) + - [YAML Unmarshaler](#yaml-unmarshaler) + - [TOML Unmarshaler](#toml-unmarshaler) + - [INI Unmarshaler](#ini-unmarshaler) +- [Parse Accept-Language](#parse-accept-language) +- [Performance](#performance) + +  + +## Installation + +```bash +$ go get github.com/kaptinlin/go-i18n@latest +``` + +  + +## Getting started + +Create a folder named `./locales` and put some `YAML`, `TOML`, `INI` or `JSON` files. + +```sh +│ main.go +└───locales + ├───en.json + └───zh-Hans.json +``` + +Now, put the key-values content for each locale, e.g. + +**locales/en.json** +```json +{ + "hello": "Hello, {name}" +} +``` + +**locales/zh-Hans.json** +```json +{ + "hello": "你好, {name}" +} +``` + +**main.go** + +```go +package main + +import ( + "github.com/kaptinlin/go-i18n" + "fmt" +) + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + ) + + err := bundle.LoadFiles("./locales/zh-Hans.json", "./locales/en.json") + if err != nil { + fmt.Println(err) + } + + localizer := bundle.NewLocalizer("zh-Hans") + + // Output: 你好, John + fmt.Println(localizer.Get("hello", i18n.Vars{ + "name": "John", + })) +} +``` + +  + +## Advanced Configuration + +### Custom Formatters + +Add custom formatters for domain-specific formatting needs: + +```go +bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithCustomFormatters(map[string]interface{}{ + "upper": func(value interface{}, locale string, arg *string) interface{} { + return strings.ToUpper(fmt.Sprintf("%v", value)) + }, + "currency": func(value interface{}, locale string, arg *string) interface{} { + // Custom currency formatting + return fmt.Sprintf("$%.2f", value) + }, + }), +) + +localizer := bundle.NewLocalizer("en") +result, _ := localizer.Format("Hello, {name, upper}!", i18n.Vars{ + "name": "world", +}) +// Output: Hello, WORLD! +``` + +### Strict Mode + +Enable strict parsing for better error detection: + +```go +bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithStrictMode(true), +) +``` + +### MessageFormat Options + +Configure MessageFormat behavior: + +```go +import mf "github.com/kaptinlin/messageformat-go/v1" + +options := &mf.MessageFormatOptions{ + Strict: true, + Currency: "USD", + // Add other MessageFormat options +} + +bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithMessageFormatOptions(options), +) +``` + +  + +## Loading Methods + +## Load from Go map + +```go +package main + +import "github.com/kaptinlin/go-i18n" + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + ) + + bundle.LoadMessages(map[string]map[string]string{ + "en": map[string]string{ + "hello_world": "hello, world", + }, + "zh-Hans": map[string]string{ + "hello_world": "你好，世界", + }, + }) +} +``` + +  + +## Load from Files + +```go +package main + +import "github.com/kaptinlin/go-i18n" + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + ) + + bundle.LoadFiles("./locales/en.json", "./locales/zh-Hans.json") +} +``` + +Filenames like `zh-Hans.json` `zh-Hans.user.json` will be combined to a single `zh-Hans` translation. + +No matter if you are naming them like `zh_CN`, `zh-Hans` or `ZH_CN`, they will always be converted to `zh-Hans`. + +  + +## Load from Glob Matching Files + +```go +package main + +import "github.com/kaptinlin/go-i18n" + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + ) + + bundle.LoadGlob("./locales/*.json") +} +``` + +The glob pattern adds all files within `locales` directory with the `.json` extension + +  + +## Load from Embedded Files + +Use `LoadFS` if you are using `go:embed` to compile your translations to the program. + +```go +package main + +import "github.com/kaptinlin/go-i18n" + +//go:embed locales/*.json +var localesFS embed.FS + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + ) + + // Load all json files under `locales` folder from the filesystem. + bundle.LoadFS(localesFS, "locales/*.json") +} +``` + +  + +## Translations + +Translations named like `welcome_message`, `button_create`, `button_buy` are token-based translations. For text-based, check the chapters below. + +```json +{ + "hello_world": "你好，世界" +} +``` + +```go +localizer := bundle.NewLocalizer("zh-Hans") + +// Output: 你好，世界 +localizer.Get("hello_world") + +// Output: message_what_is_this +localizer.Get("message_what_is_this") +``` + +Languages named like `zh_cn`, `zh-Hans` or `ZH_CN`, `NewLocalizer` will always convert them to `zh-Hans`. + +  + +### Passing Data to Translation + +It's possible to pass the data to translations. [ICU MessageFormat](https://unicode-org.github.io/icu/userguide/format_parse/messages/) is used to parse the text, the templates will be parsed and cached after the translation was loaded. + +```json +{ + "message_vars": "你好，{Name}" +} +``` + +```go +// Output: 你好，Yami +localizer.Get("message_vars", i18n.Vars{ + "Name": "Yami", +}) +``` + +### Direct Formatting + +Use the `Format` method to compile and format MessageFormat strings directly: + +```go +localizer := bundle.NewLocalizer("en") + +result, err := localizer.Format("Hello, {name}!", i18n.Vars{ + "name": "Alice", +}) +// Output: Hello, Alice! + +result, err = localizer.Format("{count, plural, =0 {no items} one {# item} other {# items}}", i18n.Vars{ + "count": 5, +}) +// Output: 5 items +``` + +  + +## Pluralization + +Using language specific plural forms (`one`, `other`) + +```json +{ + "message": "{count, plural, one {Message} other {Messages}}" +} +``` + +```go +// Output: Message +localizer.Get("message", i18n.Vars{ + "count": 1, +}) + +// Output: Messages +localizer.Get("message", i18n.Vars{ + "count": 2, +}) +``` + +Using exact matches (`=0`): +```json +{ + "messages": "{count, plural, =0 {No messages} one {1 message} other {# messages}}" +} +``` + +```go +// Output: No messages +localizer.Get("messages", i18n.Vars{ + "count": 0, +}) + +// Output: 1 message +localizer.Get("messages", i18n.Vars{ + "count": 1, +}) + +// Output: 2 messages +localizer.Get("messages", i18n.Vars{ + "count": 2, +}) +``` + +  + +## Text-based Translations + +Translations can also be named with sentences so it will act like fallbacks when the translation was not found. + +```json +{ + "I'm fine.": "我过得很好。", + "How about you?": "你如何呢？" +} +``` + +```go +// Output: 我过得很好。 +localizer.Get("I'm fine.") + +// Output: 你如何呢？ +localizer.Get("How about you?") + +// Output: Thank you! +localizer.Get("Thank you!") +``` + +  + +### Disambiguation by context + +In English a "Post" can be "Post something (verb)" or "A post (noun)". With token-based translation, you can easily separating them to `post_verb` and `post_noun`. + +With text-based translation, you will need to use `GetX` (X stands for context), and giving the translation a `` suffix. + +The space before the `<` is **REQUIRED**. + +```json +{ + "Post ": "发表文章", + "Post ": "一篇文章" +} +``` + +```go +// Output: 发表文章 +localizer.GetX("Post", "verb") + +// Output: 一篇文章 +localizer.GetX("Post", "noun") + +// Output: Post +localizer.GetX("Post", "adjective") +``` + +  + +### Act as fallback + +Remember, if a translation was not found, the token name will be output directly. The token name can also be used as template content. + +```go +// Output: Hello, World +localizer.Get("Hello, {Name}", i18n.Vars{ + "Name": "World", +}) + +// Output: 2 Posts +localizer.Get("{count, plural, =0 {No Post} one {1 Post} other {# Posts}}", i18n.Vars{ + "Count": 2, +}) +``` + +  + +## Fallbacks + +A fallback language will be used when a translation is missing from the current language. If it's still missing from the fallback language, it will lookup from the default language. + +If a translation cannot be found from any language, the token name will be output directly. + +```go +// `ja-jp` is the default language +bundle :=i18n.New( + i18n.WithDefaultLocale("ja-JP"), + i18n.WithFallback(map[string][]string{ + // `zh-Hans` uses `zh`, `zh-Hant` as fallbacks. + // `en-GB` uses `en-US` as fallback. + "zh-Hans": []string{"zh", "zh-Hant"}, + "en-GB": []string{"en-US"}, + }, +)) +``` + +Lookup path looks like this with the example above: + +``` +zh-Hans -> zh -> zh-Hant -> ja-JP +en-GB -> en-US -> ja-JP +``` + +Recursive fallback is also supported. If `zh-Hans` has a `zh` fallback, and `zh` has a `zh-Hant` fallback, `zh-Hans` will have either `zh` and `zh-Hant` fallbacks. + +Fallback only works if the translation exists in default language. + +  + +## Custom Unmarshaler + +Translations are JSON format by default using `github.com/go-json-experiment/json` as the default unmarshaler. Change it by calling `WithUnmarshaler`. + +### YAML Unmarshaler +Uses [`go-yaml/yaml`](https://github.com/go-yaml/yaml) to read the files, so you can write the translation files in YAML format. + +```go +package main + +import "gopkg.in/yaml.v3" + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + i18n.WithUnmarshaler(yaml.Unmarshal), + ) +} +``` + +Your `zh-Hans.yaml` should look like this: + +```yaml +hello_world: "你好，世界" +"How are you?": "你过得如何？" +"mobile_interface.button": "按钮" +``` + +Nested translations are not supported, you will need to name them like `"mobile_interface.button"` as key and quote them in double quotes. + +  + +### TOML Unmarshaler + +Uses [`pelletier/go-toml`](https://github.com/pelletier/go-toml) to read the files, so you can write the translation files in TOML format. + +```go +package main + +import "github.com/pelletier/go-toml/v2" + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + i18n.WithUnmarshaler(toml.Unmarshal), + ) +} +``` + +Your `zh-Hans.toml` should look like this: + +```toml +hello_world = "你好, 世界" +hello_name = "你好, {name}" +message = "{count, plural, one {消息} other {消息}}" +message_with_number = "{count, plural, =0 {没有消息} one {1 条消息} other {# 条消息}}" +``` + +  + +### INI Unmarshaler + +Uses [`go-ini/ini`](https://gopkg.in/ini.v1) to read the files, so you can write the translation files in INI format. + +```go +package main + +import "gopkg.in/ini.v1" + +func unmarshalINI(data []byte, v interface{}) error { + f, err := ini.LoadSources(ini.LoadOptions{ + SpaceBeforeInlineComment: true, + IgnoreInlineComment: true, + }, data) + if err != nil { + return err + } + + m := *v.(*map[string]string) + + for _, section := range f.Sections() { + keyPrefix := "" + if name := section.Name(); name != ini.DefaultSection { + keyPrefix = name + "." + } + + for _, key := range section.Keys() { + m[keyPrefix+key.Name()] = key.Value() + } + } + + return nil +} + +func main() { + bundle := i18n.NewBundle( + i18n.WithDefaultLocale("en"), + i18n.WithLocales("en", "zh-Hans"), + i18n.WithUnmarshaler(unmarshalINI), + ) +} +``` + +Your `zh-Hans.ini` should look like this: + +```ini +hello_world=你好, 世界 +hello_name=你好, {name} +message={count, plural, one {消息} other {消息}} + +[message] +with_number="{count, plural, =0 {没有消息} one {1 条消息} other {# 条消息}}" +``` + +  + +## Parse Accept-Language + +The built-in `MatchAvailableLocale` function helps you to parse the `Accept-Language` from HTTP Header. + +```go +func(w http.ResponseWriter, r *http.Request) { + // Initialize i18n. + bundle :=i18n.NewBundle( + i18n.WithDefaultLocale("zh-Hans"), + i18n.WithLocales("en", "zh-Hans"), + ) + bundle.LoadFiles("zh-Hans.json", "en.json") + + // Get `Accept-Language` from request header. + accept := r.Header.Get("Accept-Language") + + // Use the locale. + localizer := bundle.NewLocalizer(bundle.MatchAvailableLocale(accept)) + localizer.Get("hello_world") +} +``` + +Orders of the languages that passed to `NewLocalizer` won't affect the fallback priorities, it will use the first language that was found in loaded translations. + +  + +## Performance + +This library is optimized with Go 1.26 features for maximum performance: + +### Optimizations Applied + +- **Built-in Functions**: Uses `min()`, `max()`, and `clear()` for efficient operations +- **Slices Package**: Pre-allocation with `slices.Grow()`, deduplication with `slices.Compact()` +- **Maps Package**: Bulk copying with `maps.Copy()` instead of element-by-element assignment +- **String Processing**: `strings.Cut()` and `strings.Builder` for reduced memory allocations +- **Memory Pre-allocation**: Smart capacity estimation for slices and maps +- **Modern MessageFormat**: 10-50x performance improvement over previous engines + +### Benchmarks + +The modernized codebase shows significant improvements: +- **String normalization**: 40-60% faster with reduced allocations +- **File loading**: 25-35% faster with batch operations +- **Translation lookup**: Optimized with pre-allocated data structures +- **MessageFormat parsing**: 10-50x faster with new engine + +  + +## Thanks + +- https://github.com/teacat/i18n +- https://github.com/kataras/i18n +- https://github.com/nicksnyder/go-i18n +- https://github.com/vorlif/spreak +- https://github.com/oblq/i18n + +## License + +`kaptinlin/i18n` is free and open-source software licensed under the [MIT License](https://tldrlegal.com/license/mit-license). diff --git a/vendor/github.com/moby/go-archive/archive.go b/vendor/github.com/moby/go-archive/archive.go index 7a105aef1..8dce2e6e2 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 4d8824158..58a03e4a6 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 2ec7706a1..579ce5530 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 de7230d28..a6df39c67 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 902727fb8..10f543fa4 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 fc70dfaa4..06763b4bc 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 85eaf3e7e..9730a61c2 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 27f4c06c1..d3913197a 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 e8d699766..d5268ab53 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 0ce35e3c5..470a1af2f 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 eb2064c80..2ce99086a 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 d211a73aa..52133f0a8 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 4070da211..847d2946e 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 ecafebd8d..957ec2b33 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 c7454d03d..b557da0de 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 6287eb46a..b7c7b7259 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 ca1493d87..50e323dbe 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 0be048a38..b4b43ac61 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 2d3c32fa8..f95f8c300 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 2bd3e568d..860878747 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 c61a470fb..d3b6dbc53 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 8e69d7cb1..2effcadf8 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 8232c483c..48f2804d9 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 107b574f8..3e0aeb26a 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 c6ec17e9c..4072f19cf 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 a1dc14d21..9e23edb6e 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 4ab02d03b..9b37d296a 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 3f4416bfd..a6000a3c5 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()) } +// 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) + } + + 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 +} + 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 + processorPackages, err := getSystemLogicalProcessorInformationEx(relationProcessorPackage) + if err != nil { + return ret, fmt.Errorf("failed to get processor package information: %w", err) } - var procID string - for i, l := range dst { - procID = "" - if l.ProcessorID != nil { - procID = *l.ProcessorID - } + 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 + } - cpu := InfoStat{ + 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, 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), + Family: strconv.FormatUint(uint64(family), 10), + VendorID: vendorId, + ModelName: model, + Cores: int32(logicalCount), + PhysicalID: processorId, + Mhz: float64(maxMhz), Flags: []string{}, - } - ret = append(ret, cpu) + }) } 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 11a4fd410..000000000 --- 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 d48b41e51..f0d3c4546 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 000000000..5579c3bcc --- /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 c9d610540..384b4c5a7 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() +// Library represents a dynamic library loaded by purego. +type library struct { + handle uintptr + fnMap map[string]any +} + +// library paths +const ( + 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) { + lib, err := purego.Dlopen(path, purego.RTLD_LAZY|purego.RTLD_GLOBAL) 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 + return nil, err } - if length == 0 { - var b []byte - return b, length, err + + return &library{ + handle: lib, + fnMap: make(map[string]any), + }, nil +} + +func (lib *library) Dlsym(symbol string) (uintptr, error) { + return purego.Dlsym(lib.handle, symbol) +} + +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 } - // 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 dlfun.fn +} + +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 +} - return buf, length, nil +func (c *CoreFoundationLib) CFGetTypeID(cf uintptr) int64 { + fn := getFunc[CFGetTypeIDFunc](c.library, "CFGetTypeID") + return fn(cf) } -// Library represents a dynamic library loaded by purego. -type Library struct { - addr uintptr - path string - close func() +func (c *CoreFoundationLib) CFNumberCreate(allocator uintptr, theType int64, valuePtr uintptr) unsafe.Pointer { + fn := getFunc[CFNumberCreateFunc](c.library, "CFNumberCreate") + return fn(allocator, theType, valuePtr) } -// library paths -const ( - IOKit = "/System/Library/Frameworks/IOKit.framework/IOKit" - CoreFoundation = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation" - System = "/usr/lib/libSystem.B.dylib" -) +func (c *CoreFoundationLib) CFNumberGetValue(num uintptr, theType int64, valuePtr uintptr) bool { + fn := getFunc[CFNumberGetValueFunc](c.library, "CFNumberGetValue") + return fn(num, theType, valuePtr) +} -func NewLibrary(path string) (*Library, error) { - lib, err := purego.Dlopen(path, purego.RTLD_LAZY|purego.RTLD_GLOBAL) +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) +} - closeFunc := func() { - purego.Dlclose(lib) +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 +} - return &Library{ - addr: lib, - path: path, - close: closeFunc, - }, 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 (lib *Library) Dlsym(symbol string) (uintptr, error) { - return purego.Dlsym(lib.addr, symbol) +func (s *SystemLib) VMDeallocate(targetTask uint32, vmAddress, vmSize uintptr) int32 { + fn := getFunc[VMDeallocateFunc](s.library, "vm_deallocate") + return fn(targetTask, vmAddress, vmSize) } -func GetFunc[T any](lib *Library, symbol string) T { - var fptr T - purego.RegisterLibFunc(&fptr, lib.addr, symbol) - return fptr +func (s *SystemLib) ProcPidPath(pid int32, buffer uintptr, bufferSize uint32) int32 { + fn := getFunc[ProcPidPathFunc](s.library, "proc_pidpath") + return fn(pid, buffer, bufferSize) } -func (lib *Library) Close() { - lib.close() +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 53cdceeb6..7a40a40c2 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 ffaae423b..a2473f41d 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 206532126..52796ddbf 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 00fa19a2f..df44ac042 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 55f36f1f3..000000000 --- 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 f3ec5a986..31df6efe9 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 888cc57fa..6bbfc2d72 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 0a12fe2fe..b69dfb605 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 c1a9ed12d..907143d3e 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 0da71a988..f4f46f0d2 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 7d96a3bb0..1b3e9f21b 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 3e6e4e3e4..9d969ba83 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 680cad12b..1cb785f04 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 d5a93f41f..4531dd444 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+)$`) -// 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 +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) } - return Addr{IP: host, Port: uint32(lport)}, nil } + 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) +// 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) { + 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 f01b04b50..d1e7f0ce7 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 55087ce37..ec4cfb957 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 +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) } - return Addr{IP: host, Port: uint32(lport)}, nil } + 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 7c5153d30..c491a2911 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 962289699..f530e4e57 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 0bd4d9e1a..5db5ff481 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 1a58c3eca..d094d389d 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 91f393203..d7fb921cb 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 890a5d533..a40f96195 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 8075cf227..7ab1afb11 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 b01429734..699311a9c 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 6df31421c..283af9bb3 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 f44f6bc6f..764523dcf 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 063ff20ca..31fdb85bc 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 7f6877182..bdb07ff28 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 9fe55b490..06642238d 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 6af5633e0..547d22872 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 b4748d38e..a1e28be69 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 b5fd75ccc..1693b100b 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 05ecd658e..6f68a9370 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 9d1e91d32..c66a8c69b 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 de6ccbd88..5b7c50001 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 a19469138..28f9305d0 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 9c8839c94..ff0b12f9d 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 10adfad8d..bb86a9fab 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 b0f2273a3..49c421a7d 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 9a2421485..9cfe50fcc 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 58b3ef263..6472a9738 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 e9eea1efe..ea6522406 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 e00160262..90793f3fc 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 4251b85b9..295c1a6a7 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 ac77b5b3b..e4e13b809 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 007eaa774..6e5f455d8 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 9d4ec10f9..6a3c62386 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 4e46f0e38..4f5c555e5 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 861bf7492..eb23d2ba0 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 3e3919a6f..1b8cc946d 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 1b27f1962..61724abec 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.20 + GO_VERSION: go1.25.0 -freebsd_12_task: +freebsd_13_task: freebsd_instance: - image_family: freebsd-12-3 + image_family: freebsd-13-5 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest @@ -12,9 +12,9 @@ freebsd_12_task: build_script: bin/${GO_VERSION} build -v ./... test_script: bin/${GO_VERSION} test -race ./... -freebsd_13_task: +freebsd_14_task: freebsd_instance: - image_family: freebsd-13-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_bsd.go b/vendor/github.com/tklauser/go-sysconf/sysconf_bsd.go index 7c96157bb..ec81c02ac 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_bsd.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_bsd.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build darwin || dragonfly || freebsd || netbsd || openbsd -// +build darwin dragonfly freebsd netbsd openbsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_darwin.go b/vendor/github.com/tklauser/go-sysconf/sysconf_darwin.go index 3f5d83f69..b471ec104 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_darwin.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_darwin.go @@ -16,6 +16,10 @@ const ( _HOST_NAME_MAX = _MAXHOSTNAMELEN - 1 _LOGIN_NAME_MAX = _MAXLOGNAME _SYMLOOP_MAX = _MAXSYMLINKS + + // _PTHREAD_STACK_MIN changed in macOS 14 + _PTHREAD_STACK_MIN_LT_MACOS14 = 0x2000 + _PTHREAD_STACK_MIN_GE_MACOS14 = 0x4000 ) var uname struct { @@ -23,6 +27,21 @@ var uname struct { macOSMajor int } +func getMacOSMajor() int { + uname.Once.Do(func() { + var u unix.Utsname + err := unix.Uname(&u) + if err != nil { + return + } + rel := unix.ByteSliceToString(u.Release[:]) + ver := strings.Split(rel, ".") + maj, _ := strconv.Atoi(ver[0]) + uname.macOSMajor = maj + }) + return uname.macOSMajor +} + // sysconf implements sysconf(4) as in the Darwin libc (derived from the FreeBSD // libc), version 1534.81.1. // See https://github.com/apple-oss-distributions/Libc/tree/Libc-1534.81.1. @@ -91,7 +110,10 @@ func sysconf(name int) (int64, error) { case SC_THREAD_PRIO_PROTECT: return _POSIX_THREAD_PRIO_PROTECT, nil case SC_THREAD_STACK_MIN: - return _PTHREAD_STACK_MIN, nil + if getMacOSMajor() < 23 { + return _PTHREAD_STACK_MIN_LT_MACOS14, nil + } + return _PTHREAD_STACK_MIN_GE_MACOS14, nil case SC_THREAD_THREADS_MAX: return -1, nil case SC_TIMER_MAX: @@ -140,18 +162,7 @@ func sysconf(name int) (int64, error) { } return _POSIX_SEMAPHORES, nil case SC_SPAWN: - uname.Once.Do(func() { - var u unix.Utsname - err := unix.Uname(&u) - if err != nil { - return - } - rel := unix.ByteSliceToString(u.Release[:]) - ver := strings.Split(rel, ".") - maj, _ := strconv.Atoi(ver[0]) - uname.macOSMajor = maj - }) - if uname.macOSMajor < 22 { + if getMacOSMajor() < 22 { return -1, nil } // macOS 13 (Ventura) and later diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_generic.go b/vendor/github.com/tklauser/go-sysconf/sysconf_generic.go index 248bdc99c..7dcc6f4ca 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_generic.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_generic.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd -// +build darwin dragonfly freebsd linux netbsd openbsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_linux.go b/vendor/github.com/tklauser/go-sysconf/sysconf_linux.go index 5fb49ac7b..9af70070e 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_linux.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_linux.go @@ -6,7 +6,6 @@ package sysconf import ( "bufio" - "io/ioutil" "os" "runtime" "strconv" @@ -26,7 +25,7 @@ const ( ) func readProcFsInt64(path string, fallback int64) int64 { - data, err := ioutil.ReadFile(path) + data, err := os.ReadFile(path) if err != nil { return fallback } @@ -86,10 +85,16 @@ func getNprocsProcStat() (int64, error) { s := bufio.NewScanner(f) for s.Scan() { if line := strings.TrimSpace(s.Text()); strings.HasPrefix(line, "cpu") { - l := strings.SplitN(line, " ", 2) - _, err := strconv.ParseInt(l[0][3:], 10, 64) - if err == nil { - count++ + cpu, _, found := strings.Cut(line, " ") + if found { + // skip first line with accumulated values + if cpu == "cpu" { + continue + } + _, err := strconv.ParseInt(cpu[len("cpu"):], 10, 64) + if err == nil { + count++ + } } } else { // The current format of /proc/stat has all the @@ -98,6 +103,9 @@ func getNprocsProcStat() (int64, error) { break } } + if err := s.Err(); err != nil { + return -1, err + } return count, nil } diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go b/vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go index 325d4a6a8..87cf6a10a 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 int64 - clktckOnce sync.Once -) +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 @@ -42,7 +45,6 @@ func sysconf(name int) (int64, error) { // Duplicate the relevant values here. switch name { - // 1003.1 case SC_ARG_MAX: return sysctl32("kern.argmax"), nil @@ -55,13 +57,7 @@ func sysconf(name int) (int64, error) { } return -1, nil case SC_CLK_TCK: - clktckOnce.Do(func() { - clktck = -1 - if ci, err := unix.SysctlClockinfo("kern.clockrate"); err == nil { - clktck = int64(ci.Hz) - } - }) - return clktck, nil + return clktck(), nil case SC_NGROUPS_MAX: return sysctl32("kern.ngroups"), nil case SC_JOB_CONTROL: diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_posix.go b/vendor/github.com/tklauser/go-sysconf/sysconf_posix.go index e61c0bc73..830d8220b 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_posix.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_posix.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build darwin || dragonfly || freebsd || linux || openbsd -// +build darwin dragonfly freebsd linux openbsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/sysconf_unsupported.go b/vendor/github.com/tklauser/go-sysconf/sysconf_unsupported.go index 478d69200..5aa9119db 100644 --- a/vendor/github.com/tklauser/go-sysconf/sysconf_unsupported.go +++ b/vendor/github.com/tklauser/go-sysconf/sysconf_unsupported.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris -// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_darwin.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_darwin.go index 6fadf3db1..80b64393b 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_darwin.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_darwin.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_darwin.go //go:build darwin -// +build darwin package sysconf @@ -235,7 +234,6 @@ const ( _PTHREAD_DESTRUCTOR_ITERATIONS = 0x4 _PTHREAD_KEYS_MAX = 0x200 - _PTHREAD_STACK_MIN = 0x2000 ) const ( diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_dragonfly.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_dragonfly.go index 0864cd448..dae56570c 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_dragonfly.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_dragonfly.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_dragonfly.go //go:build dragonfly -// +build dragonfly package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_freebsd.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_freebsd.go index 9885411ac..068f8a7ed 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_freebsd.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_freebsd.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_freebsd.go //go:build freebsd -// +build freebsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_linux.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_linux.go index 8545a342b..12f289d76 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_linux.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_linux.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_linux.go //go:build linux -// +build linux package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_netbsd.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_netbsd.go index d2aaf0777..772af475a 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_netbsd.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_netbsd.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_netbsd.go //go:build netbsd -// +build netbsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_openbsd.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_openbsd.go index badc66cbd..625b098f9 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_openbsd.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_openbsd.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_openbsd.go //go:build openbsd -// +build openbsd package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_solaris.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_solaris.go index 29b6f8746..c155cf579 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_solaris.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_defs_solaris.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_defs_solaris.go //go:build solaris -// +build solaris package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_386.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_386.go index 478fe63a9..b5d480748 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_386.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_386.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_freebsd.go //go:build freebsd && 386 -// +build freebsd,386 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_amd64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_amd64.go index 7f58a4d8b..89c880aae 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_amd64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_amd64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_freebsd.go //go:build freebsd && amd64 -// +build freebsd,amd64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm.go index deb47595b..7b65fdd6f 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_freebsd.go //go:build freebsd && arm -// +build freebsd,arm package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm64.go index 556ba3da2..a86cb32bd 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_freebsd.go //go:build freebsd && arm64 -// +build freebsd,arm64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_riscv64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_riscv64.go index b7cff760b..6c847aeea 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_riscv64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_riscv64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_freebsd.go //go:build freebsd && riscv64 -// +build freebsd,riscv64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_386.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_386.go index 16ee7ea64..90963eb42 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_386.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_386.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && 386 -// +build linux,386 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_amd64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_amd64.go index 39aee349f..28ad6f183 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_amd64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_amd64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && amd64 -// +build linux,amd64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm.go index 2e401164e..ffbcf37d4 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && arm -// +build linux,arm package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm64.go index 362403abc..cc9f4d88d 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && arm64 -// +build linux,arm64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_loong64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_loong64.go index 95a71f4a2..f62b15a69 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_loong64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_loong64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && loong64 -// +build linux,loong64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips.go index 868b0ffb3..37f492a81 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && mips -// +build linux,mips package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64.go index 5949f3d71..ae7b7f9c2 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && mips64 -// +build linux,mips64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64le.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64le.go index 1853419a3..fe14670f2 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64le.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64le.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && mips64le -// +build linux,mips64le package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mipsle.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mipsle.go index ff41b3469..d204585be 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mipsle.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mipsle.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && mipsle -// +build linux,mipsle package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64.go index 388743728..9ec78d335 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && ppc64 -// +build linux,ppc64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64le.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64le.go index 6d76929a6..a54206729 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64le.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64le.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && ppc64le -// +build linux,ppc64le package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_riscv64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_riscv64.go index 3d7d71b32..bfb923920 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_riscv64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_riscv64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && riscv64 -// +build linux,riscv64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_s390x.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_s390x.go index 9cf8529f5..6e935c873 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_s390x.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_s390x.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_linux.go //go:build linux && s390x -// +build linux,s390x package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_386.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_386.go index 3cd64dd66..ea0b24a82 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_386.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_386.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_netbsd.go //go:build netbsd && 386 -// +build netbsd,386 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_amd64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_amd64.go index 02fc1d0ef..2d377e253 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_amd64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_amd64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_netbsd.go //go:build netbsd && amd64 -// +build netbsd,amd64 package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm.go index 16f9b6e71..4a6d83670 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_netbsd.go //go:build netbsd && arm -// +build netbsd,arm package sysconf diff --git a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm64.go b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm64.go index e530339ca..49fb6725e 100644 --- a/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm64.go +++ b/vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm64.go @@ -2,7 +2,6 @@ // cgo -godefs sysconf_values_netbsd.go //go:build netbsd && arm64 -// +build netbsd,arm64 package sysconf diff --git a/vendor/github.com/tklauser/numcpus/.cirrus.yml b/vendor/github.com/tklauser/numcpus/.cirrus.yml index 69c6ced5c..61724abec 100644 --- a/vendor/github.com/tklauser/numcpus/.cirrus.yml +++ b/vendor/github.com/tklauser/numcpus/.cirrus.yml @@ -1,13 +1,23 @@ env: CIRRUS_CLONE_DEPTH: 1 - GO_VERSION: go1.20 + GO_VERSION: go1.25.0 -freebsd_12_task: +freebsd_13_task: freebsd_instance: - image_family: freebsd-12-3 + image_family: freebsd-13-5 install_script: | pkg install -y go GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest bin/${GO_VERSION} download - build_script: bin/${GO_VERSION} build -buildvcs=false -v ./... - test_script: bin/${GO_VERSION} test -buildvcs=false -race ./... + build_script: bin/${GO_VERSION} build -v ./... + test_script: bin/${GO_VERSION} test -race ./... + +freebsd_14_task: + freebsd_instance: + image_family: freebsd-14-2 + install_script: | + pkg install -y go + GOBIN=$PWD/bin go install golang.org/dl/${GO_VERSION}@latest + bin/${GO_VERSION} download + build_script: bin/${GO_VERSION} build -v ./... + test_script: bin/${GO_VERSION} test -race ./... diff --git a/vendor/github.com/tklauser/numcpus/numcpus.go b/vendor/github.com/tklauser/numcpus/numcpus.go index af59983e7..de206f061 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_bsd.go b/vendor/github.com/tklauser/numcpus/numcpus_bsd.go index 9e77e38e6..efd8db0f1 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus_bsd.go +++ b/vendor/github.com/tklauser/numcpus/numcpus_bsd.go @@ -13,7 +13,6 @@ // limitations under the License. //go:build darwin || dragonfly || freebsd || netbsd || openbsd -// +build darwin dragonfly freebsd netbsd openbsd package numcpus diff --git a/vendor/github.com/tklauser/numcpus/numcpus_linux.go b/vendor/github.com/tklauser/numcpus/numcpus_linux.go index 1a30525b8..d05ee9825 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus_linux.go +++ b/vendor/github.com/tklauser/numcpus/numcpus_linux.go @@ -15,7 +15,7 @@ package numcpus import ( - "io/ioutil" + "fmt" "os" "path/filepath" "strconv" @@ -24,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 @@ -34,38 +41,87 @@ func getFromCPUAffinity() (int, error) { return cpuSet.Count(), nil } -func readCPURange(file string) (int, error) { - buf, err := ioutil.ReadFile(filepath.Join(sysfsCPUBasePath, file)) +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) } - rangeOp := strings.SplitN(cpuRange, "-", 2) - first, err := strconv.ParseUint(rangeOp[0], 10, 32) + from, to, found := strings.Cut(cpuRange, "-") + first, err := strconv.ParseUint(from, 10, 32) if err != nil { return 0, err } - if len(rangeOp) == 1 { + if !found { n++ continue } - last, err := strconv.ParseUint(rangeOp[1], 10, 32) + last, err := strconv.ParseUint(to, 10, 32) 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 { @@ -89,7 +145,7 @@ func getConfigured() (int, error) { } func getKernelMax() (int, error) { - buf, err := ioutil.ReadFile(filepath.Join(sysfsCPUBasePath, "kernel_max")) + buf, err := os.ReadFile(filepath.Join(sysfsCPUBasePath, "kernel_max")) if err != nil { return 0, err } @@ -101,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 000000000..af4efeacf --- /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/github.com/tklauser/numcpus/numcpus_solaris.go b/vendor/github.com/tklauser/numcpus/numcpus_solaris.go index a26432378..f3b632fe7 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus_solaris.go +++ b/vendor/github.com/tklauser/numcpus/numcpus_solaris.go @@ -13,7 +13,6 @@ // limitations under the License. //go:build solaris -// +build solaris package numcpus diff --git a/vendor/github.com/tklauser/numcpus/numcpus_unsupported.go b/vendor/github.com/tklauser/numcpus/numcpus_unsupported.go index 4a0b7c43d..e72355eca 100644 --- a/vendor/github.com/tklauser/numcpus/numcpus_unsupported.go +++ b/vendor/github.com/tklauser/numcpus/numcpus_unsupported.go @@ -13,7 +13,6 @@ // limitations under the License. //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows -// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!windows package numcpus diff --git a/vendor/modules.txt b/vendor/modules.txt index 5cc8d0b58..9abf6403d 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -5,7 +5,7 @@ dario.cat/mergo ## explicit; go 1.24.0 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 @@ -149,7 +149,7 @@ github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa # github.com/distribution/reference v0.6.0 ## explicit; go 1.20 github.com/distribution/reference -# 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 @@ -192,12 +192,13 @@ github.com/eapache/go-resiliency/breaker # github.com/eapache/queue v1.1.0 ## explicit github.com/eapache/queue -# 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/felixge/httpsnoop v1.0.4 ## explicit; go 1.13 github.com/felixge/httpsnoop @@ -540,7 +541,7 @@ github.com/miekg/pkcs11 # 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 @@ -558,7 +559,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 @@ -623,7 +624,7 @@ github.com/pkg/errors # github.com/pmezard/go-difflib v1.0.0 ## 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 @@ -696,8 +697,8 @@ github.com/segmentio/asm/cpu/arm64 github.com/segmentio/asm/cpu/cpuid github.com/segmentio/asm/cpu/x86 github.com/segmentio/asm/internal/unsafebytes -# 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 @@ -748,8 +749,8 @@ github.com/swaggo/gin-swagger # github.com/swaggo/swag v1.16.6 ## explicit; go 1.18 github.com/swaggo/swag -# 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 @@ -761,11 +762,11 @@ github.com/testcontainers/testcontainers-go/wait # github.com/tiendc/go-deepcopy v1.7.2 ## explicit; go 1.18 github.com/tiendc/go-deepcopy -# github.com/tklauser/go-sysconf v0.3.12 -## explicit; go 1.13 +# github.com/tklauser/go-sysconf v0.3.16 +## explicit; go 1.24.0 github.com/tklauser/go-sysconf -# github.com/tklauser/numcpus v0.6.1 -## explicit; go 1.13 +# github.com/tklauser/numcpus v0.11.0 +## explicit; go 1.24.0 github.com/tklauser/numcpus # github.com/twitchyliquid64/golang-asm v0.15.1 ## explicit; go 1.13