diff --git a/go.mod b/go.mod index 6d6e833c..f9f2b826 100644 --- a/go.mod +++ b/go.mod @@ -1,49 +1,48 @@ module github.com/cea-hpc/sshproxy -go 1.24.0 - -toolchain go1.24.9 +go 1.25.0 require ( github.com/creack/pty v1.1.24 - github.com/ebitengine/purego v0.9.1 + github.com/ebitengine/purego v0.10.0 github.com/iskylite/nodeset v1.0.1 github.com/moby/term v0.5.2 - github.com/olekukonko/tablewriter v1.1.0 + github.com/olekukonko/tablewriter v1.1.4 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7 - go.etcd.io/etcd/api/v3 v3.6.5 - go.etcd.io/etcd/client/v3 v3.6.5 - go.uber.org/zap v1.27.0 - golang.org/x/crypto v0.43.0 - google.golang.org/grpc v1.76.0 + go.etcd.io/etcd/api/v3 v3.6.8 + go.etcd.io/etcd/client/v3 v3.6.8 + go.uber.org/zap v1.27.1 + golang.org/x/crypto v0.49.0 + google.golang.org/grpc v1.79.3 gopkg.in/yaml.v2 v2.4.0 ) require ( github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect - github.com/clipperhouse/stringish v0.1.1 // indirect - github.com/clipperhouse/uax29/v2 v2.3.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/clipperhouse/displaywidth v0.11.0 // indirect + github.com/clipperhouse/uax29/v2 v2.7.0 // indirect github.com/coreos/go-semver v0.3.1 // indirect - github.com/coreos/go-systemd/v22 v22.6.0 // indirect + github.com/coreos/go-systemd/v22 v22.7.0 // indirect github.com/fatih/color v1.18.0 // indirect + github.com/goccy/go-json v0.10.6 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/protobuf v1.5.4 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 // indirect github.com/mattn/go-colorable v0.1.14 // indirect github.com/mattn/go-isatty v0.0.20 // indirect - github.com/mattn/go-runewidth v0.0.19 // indirect + github.com/mattn/go-runewidth v0.0.21 // indirect github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 // indirect - github.com/olekukonko/errors v1.1.0 // indirect - github.com/olekukonko/ll v0.1.2 // indirect - github.com/rivo/uniseg v0.4.7 // indirect + github.com/olekukonko/errors v1.2.0 // indirect + github.com/olekukonko/ll v0.1.7 // indirect github.com/segmentio/fasthash v1.0.3 // indirect github.com/willf/bitset v1.1.11 // indirect - go.etcd.io/etcd/client/pkg/v3 v3.6.5 // indirect + go.etcd.io/etcd/client/pkg/v3 v3.6.8 // indirect go.uber.org/multierr v1.11.0 // indirect - golang.org/x/net v0.46.0 // indirect - golang.org/x/sys v0.37.0 // indirect - golang.org/x/text v0.30.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101 // indirect - google.golang.org/protobuf v1.36.10 // indirect + golang.org/x/net v0.52.0 // indirect + golang.org/x/sys v0.42.0 // indirect + golang.org/x/text v0.35.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260316180232-0b37fe3546d5 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260316180232-0b37fe3546d5 // indirect + google.golang.org/protobuf v1.36.11 // indirect ) diff --git a/go.sum b/go.sum index 96875e51..d9edc36f 100644 --- a/go.sum +++ b/go.sum @@ -1,25 +1,29 @@ 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/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs= -github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA= -github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4= -github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8= +github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0= +github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk= +github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM= github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4= github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec= -github.com/coreos/go-systemd/v22 v22.6.0 h1:aGVa/v8B7hpb0TKl0MWoAavPDmHvobFe5R5zn0bCJWo= -github.com/coreos/go-systemd/v22 v22.6.0/go.mod h1:iG+pp635Fo7ZmV/j14KUcmEyWF+0X7Lua8rrTWzYgWU= +github.com/coreos/go-systemd/v22 v22.7.0 h1:LAEzFkke61DFROc7zNLX/WA2i5J8gYqe0rSj9KI28KA= +github.com/coreos/go-systemd/v22 v22.7.0/go.mod h1:xNUYtjHu2EDXbsxz1i41wouACIwT7Ybq9o0BQhMwD0w= github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s= github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s0A= -github.com/ebitengine/purego v0.9.1/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/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU= +github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= @@ -28,8 +32,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 h1:HWRh5R2+9EifMyIHV7ZV+MIZqgz+PMpZ14Jynv3O2Zs= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0/go.mod h1:JfhWUomR1baixubs02l85lZYYOm7LV6om4ceouMv45c= github.com/iskylite/nodeset v1.0.1 h1:2yif2U3tyioRQyWSYSRVC47DUL0Raib4Ej+tEZIFlLs= github.com/iskylite/nodeset v1.0.1/go.mod h1:PCZzSaZBqVBbiHxCJb4PVHl7m6C5+5DrD1EVMl5+Clw= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= @@ -42,24 +46,22 @@ github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHP github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw= -github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= +github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w= +github.com/mattn/go-runewidth v0.0.21/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= 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/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 h1:zrbMGy9YXpIeTnGj4EljqMiZsIcE09mmF8XsD5AYOJc= github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6/go.mod h1:rEKTHC9roVVicUIfZK7DYrdIoM0EOr8mK1Hj5s3JjH0= -github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM= -github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y= -github.com/olekukonko/ll v0.1.2 h1:lkg/k/9mlsy0SxO5aC+WEpbdT5K83ddnNhAepz7TQc0= -github.com/olekukonko/ll v0.1.2/go.mod h1:b52bVQRRPObe+yyBl0TxNfhesL0nedD4Cht0/zx55Ew= -github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY= -github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo= +github.com/olekukonko/errors v1.2.0 h1:10Zcn4GeV59t/EGqJc8fUjtFT/FuUh5bTMzZ1XwmCRo= +github.com/olekukonko/errors v1.2.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y= +github.com/olekukonko/ll v0.1.7 h1:WyK1YZwOTUKHEXZz3VydBDT5t3zDqa9yI8iJg5PHon4= +github.com/olekukonko/ll v0.1.7/go.mod h1:RPRC6UcscfFZgjo1nulkfMH5IM0QAYim0LfnMvUuozw= +github.com/olekukonko/tablewriter v1.1.4 h1:ORUMI3dXbMnRlRggJX3+q7OzQFDdvgbN9nVWj1drm6I= +github.com/olekukonko/tablewriter v1.1.4/go.mod h1:+kedxuyTtgoZLwif3P1Em4hARJs+mVnzKxmsCL/C5RY= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7 h1:lDH9UUVJtmYCjyT0CI4q8xvlXPxeZ0gYCVvWbmPlp88= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= 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/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= -github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM= @@ -71,43 +73,43 @@ github.com/willf/bitset v1.1.11 h1:N7Z7E9UvjW+sGsEl7k/SJrvY2reP1A07MrGuCjIOjRE= github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -go.etcd.io/etcd/api/v3 v3.6.5 h1:pMMc42276sgR1j1raO/Qv3QI9Af/AuyQUW6CBAWuntA= -go.etcd.io/etcd/api/v3 v3.6.5/go.mod h1:ob0/oWA/UQQlT1BmaEkWQzI0sJ1M0Et0mMpaABxguOQ= -go.etcd.io/etcd/client/pkg/v3 v3.6.5 h1:Duz9fAzIZFhYWgRjp/FgNq2gO1jId9Yae/rLn3RrBP8= -go.etcd.io/etcd/client/pkg/v3 v3.6.5/go.mod h1:8Wx3eGRPiy0qOFMZT/hfvdos+DjEaPxdIDiCDUv/FQk= -go.etcd.io/etcd/client/v3 v3.6.5 h1:yRwZNFBx/35VKHTcLDeO7XVLbCBFbPi+XV4OC3QJf2U= -go.etcd.io/etcd/client/v3 v3.6.5/go.mod h1:ZqwG/7TAFZ0BJ0jXRPoJjKQJtbFo/9NIY8uoFFKcCyo= -go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= -go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= -go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= -go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I= -go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE= -go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E= -go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI= -go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg= -go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc= -go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps= -go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4= -go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0= +go.etcd.io/etcd/api/v3 v3.6.8 h1:gqb1VN92TAI6G2FiBvWcqKtHiIjr4SU2GdXxTwyexbM= +go.etcd.io/etcd/api/v3 v3.6.8/go.mod h1:qyQj1HZPUV3B5cbAL8scG62+fyz5dSxxu0w8pn28N6Q= +go.etcd.io/etcd/client/pkg/v3 v3.6.8 h1:Qs/5C0LNFiqXxYf2GU8MVjYUEXJ6sZaYOz0zEqQgy50= +go.etcd.io/etcd/client/pkg/v3 v3.6.8/go.mod h1:GsiTRUZE2318PggZkAo6sWb6l8JLVrnckTNfbG8PWtw= +go.etcd.io/etcd/client/v3 v3.6.8 h1:B3G76t1UykqAOrbio7s/EPatixQDkQBevN8/mwiplrY= +go.etcd.io/etcd/client/v3 v3.6.8/go.mod h1:MVG4BpSIuumPi+ELF7wYtySETmoTWBHVcDoHdVupwt8= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.39.0 h1:8yPrr/S0ND9QEfTfdP9V+SiwT4E0G7Y5MO7p85nis48= +go.opentelemetry.io/otel v1.39.0/go.mod h1:kLlFTywNWrFyEdH0oj2xK0bFYZtHRYUdv1NklR/tgc8= +go.opentelemetry.io/otel/metric v1.39.0 h1:d1UzonvEZriVfpNKEVmHXbdf909uGTOQjA0HF0Ls5Q0= +go.opentelemetry.io/otel/metric v1.39.0/go.mod h1:jrZSWL33sD7bBxg1xjrqyDjnuzTUB0x1nBERXd7Ftcs= +go.opentelemetry.io/otel/sdk v1.39.0 h1:nMLYcjVsvdui1B/4FRkwjzoRVsMK8uL/cj0OyhKzt18= +go.opentelemetry.io/otel/sdk v1.39.0/go.mod h1:vDojkC4/jsTJsE+kh+LXYQlbL8CgrEcwmt1ENZszdJE= +go.opentelemetry.io/otel/sdk/metric v1.39.0 h1:cXMVVFVgsIf2YL6QkRF4Urbr/aMInf+2WKg+sEJTtB8= +go.opentelemetry.io/otel/sdk/metric v1.39.0/go.mod h1:xq9HEVH7qeX69/JnwEfp6fVq5wosJsY1mt4lLfYdVew= +go.opentelemetry.io/otel/trace v1.39.0 h1:2d2vfpEDmCJ5zVYz7ijaJdOF59xLomrvj7bjt6/qCJI= +go.opentelemetry.io/otel/trace v1.39.0/go.mod h1:88w4/PnZSazkGzz/w84VHpQafiU4EtqqlVdxWy+rNOA= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= +go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= -golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= +golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4= +golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4= -golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210= +golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= +golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -116,14 +118,14 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= -golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q= -golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss= +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.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU= +golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k= -golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM= +golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= +golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= @@ -134,14 +136,14 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= -google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101 h1:vk5TfqZHNn0obhPIYeS+cxIFKFQgser/M2jnI+9c6MM= -google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101/go.mod h1:E17fc4PDhkr22dE3RgnH2hEubUaky6ZwW4VhANxyspg= -google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101 h1:tRPGkdGHuewF4UisLzzHHr1spKw92qLM98nIzxbC0wY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= -google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A= -google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c= -google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= -google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/genproto/googleapis/api v0.0.0-20260316180232-0b37fe3546d5 h1:CogIeEXn4qWYzzQU0QqvYBM8yDF9cFYzDq9ojSpv0Js= +google.golang.org/genproto/googleapis/api v0.0.0-20260316180232-0b37fe3546d5/go.mod h1:EIQZ5bFCfRQDV4MhRle7+OgjNtZ6P1PiZBgAKuxXu/Y= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260316180232-0b37fe3546d5 h1:aJmi6DVGGIStN9Mobk/tZOOQUBbj0BPjZjjnOdoZKts= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260316180232-0b37fe3546d5/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/grpc v1.79.3 h1:sybAEdRIEtvcD68Gx7dmnwjZKlyfuc61Dyo9pGXXkKE= +google.golang.org/grpc v1.79.3/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/vendor/github.com/cespare/xxhash/v2/LICENSE.txt b/vendor/github.com/cespare/xxhash/v2/LICENSE.txt new file mode 100644 index 00000000..24b53065 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/LICENSE.txt @@ -0,0 +1,22 @@ +Copyright (c) 2016 Caleb Spare + +MIT License + +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/cespare/xxhash/v2/README.md b/vendor/github.com/cespare/xxhash/v2/README.md new file mode 100644 index 00000000..33c88305 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/README.md @@ -0,0 +1,74 @@ +# xxhash + +[![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2) +[![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml) + +xxhash is a Go implementation of the 64-bit [xxHash] algorithm, XXH64. This is a +high-quality hashing algorithm that is much faster than anything in the Go +standard library. + +This package provides a straightforward API: + +``` +func Sum64(b []byte) uint64 +func Sum64String(s string) uint64 +type Digest struct{ ... } + func New() *Digest +``` + +The `Digest` type implements hash.Hash64. Its key methods are: + +``` +func (*Digest) Write([]byte) (int, error) +func (*Digest) WriteString(string) (int, error) +func (*Digest) Sum64() uint64 +``` + +The package is written with optimized pure Go and also contains even faster +assembly implementations for amd64 and arm64. If desired, the `purego` build tag +opts into using the Go code even on those architectures. + +[xxHash]: http://cyan4973.github.io/xxHash/ + +## Compatibility + +This package is in a module and the latest code is in version 2 of the module. +You need a version of Go with at least "minimal module compatibility" to use +github.com/cespare/xxhash/v2: + +* 1.9.7+ for Go 1.9 +* 1.10.3+ for Go 1.10 +* Go 1.11 or later + +I recommend using the latest release of Go. + +## Benchmarks + +Here are some quick benchmarks comparing the pure-Go and assembly +implementations of Sum64. + +| input size | purego | asm | +| ---------- | --------- | --------- | +| 4 B | 1.3 GB/s | 1.2 GB/s | +| 16 B | 2.9 GB/s | 3.5 GB/s | +| 100 B | 6.9 GB/s | 8.1 GB/s | +| 4 KB | 11.7 GB/s | 16.7 GB/s | +| 10 MB | 12.0 GB/s | 17.3 GB/s | + +These numbers were generated on Ubuntu 20.04 with an Intel Xeon Platinum 8252C +CPU using the following commands under Go 1.19.2: + +``` +benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$') +benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$') +``` + +## Projects using this package + +- [InfluxDB](https://github.com/influxdata/influxdb) +- [Prometheus](https://github.com/prometheus/prometheus) +- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) +- [FreeCache](https://github.com/coocood/freecache) +- [FastCache](https://github.com/VictoriaMetrics/fastcache) +- [Ristretto](https://github.com/dgraph-io/ristretto) +- [Badger](https://github.com/dgraph-io/badger) diff --git a/vendor/github.com/cespare/xxhash/v2/testall.sh b/vendor/github.com/cespare/xxhash/v2/testall.sh new file mode 100644 index 00000000..94b9c443 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/testall.sh @@ -0,0 +1,10 @@ +#!/bin/bash +set -eu -o pipefail + +# Small convenience script for running the tests with various combinations of +# arch/tags. This assumes we're running on amd64 and have qemu available. + +go test ./... +go test -tags purego ./... +GOARCH=arm64 go test +GOARCH=arm64 go test -tags purego diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash.go b/vendor/github.com/cespare/xxhash/v2/xxhash.go new file mode 100644 index 00000000..78bddf1c --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash.go @@ -0,0 +1,243 @@ +// Package xxhash implements the 64-bit variant of xxHash (XXH64) as described +// at http://cyan4973.github.io/xxHash/. +package xxhash + +import ( + "encoding/binary" + "errors" + "math/bits" +) + +const ( + prime1 uint64 = 11400714785074694791 + prime2 uint64 = 14029467366897019727 + prime3 uint64 = 1609587929392839161 + prime4 uint64 = 9650029242287828579 + prime5 uint64 = 2870177450012600261 +) + +// Store the primes in an array as well. +// +// The consts are used when possible in Go code to avoid MOVs but we need a +// contiguous array for the assembly code. +var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5} + +// Digest implements hash.Hash64. +// +// Note that a zero-valued Digest is not ready to receive writes. +// Call Reset or create a Digest using New before calling other methods. +type Digest struct { + v1 uint64 + v2 uint64 + v3 uint64 + v4 uint64 + total uint64 + mem [32]byte + n int // how much of mem is used +} + +// New creates a new Digest with a zero seed. +func New() *Digest { + return NewWithSeed(0) +} + +// NewWithSeed creates a new Digest with the given seed. +func NewWithSeed(seed uint64) *Digest { + var d Digest + d.ResetWithSeed(seed) + return &d +} + +// Reset clears the Digest's state so that it can be reused. +// It uses a seed value of zero. +func (d *Digest) Reset() { + d.ResetWithSeed(0) +} + +// ResetWithSeed clears the Digest's state so that it can be reused. +// It uses the given seed to initialize the state. +func (d *Digest) ResetWithSeed(seed uint64) { + d.v1 = seed + prime1 + prime2 + d.v2 = seed + prime2 + d.v3 = seed + d.v4 = seed - prime1 + d.total = 0 + d.n = 0 +} + +// Size always returns 8 bytes. +func (d *Digest) Size() int { return 8 } + +// BlockSize always returns 32 bytes. +func (d *Digest) BlockSize() int { return 32 } + +// Write adds more data to d. It always returns len(b), nil. +func (d *Digest) Write(b []byte) (n int, err error) { + n = len(b) + d.total += uint64(n) + + memleft := d.mem[d.n&(len(d.mem)-1):] + + if d.n+n < 32 { + // This new data doesn't even fill the current block. + copy(memleft, b) + d.n += n + return + } + + if d.n > 0 { + // Finish off the partial block. + c := copy(memleft, b) + d.v1 = round(d.v1, u64(d.mem[0:8])) + d.v2 = round(d.v2, u64(d.mem[8:16])) + d.v3 = round(d.v3, u64(d.mem[16:24])) + d.v4 = round(d.v4, u64(d.mem[24:32])) + b = b[c:] + d.n = 0 + } + + if len(b) >= 32 { + // One or more full blocks left. + nw := writeBlocks(d, b) + b = b[nw:] + } + + // Store any remaining partial block. + copy(d.mem[:], b) + d.n = len(b) + + return +} + +// Sum appends the current hash to b and returns the resulting slice. +func (d *Digest) Sum(b []byte) []byte { + s := d.Sum64() + return append( + b, + byte(s>>56), + byte(s>>48), + byte(s>>40), + byte(s>>32), + byte(s>>24), + byte(s>>16), + byte(s>>8), + byte(s), + ) +} + +// Sum64 returns the current hash. +func (d *Digest) Sum64() uint64 { + var h uint64 + + if d.total >= 32 { + v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + } else { + h = d.v3 + prime5 + } + + h += d.total + + b := d.mem[:d.n&(len(d.mem)-1)] + for ; len(b) >= 8; b = b[8:] { + k1 := round(0, u64(b[:8])) + h ^= k1 + h = rol27(h)*prime1 + prime4 + } + if len(b) >= 4 { + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + } + for ; len(b) > 0; b = b[1:] { + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + } + + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} + +const ( + magic = "xxh\x06" + marshaledSize = len(magic) + 8*5 + 32 +) + +// MarshalBinary implements the encoding.BinaryMarshaler interface. +func (d *Digest) MarshalBinary() ([]byte, error) { + b := make([]byte, 0, marshaledSize) + b = append(b, magic...) + b = appendUint64(b, d.v1) + b = appendUint64(b, d.v2) + b = appendUint64(b, d.v3) + b = appendUint64(b, d.v4) + b = appendUint64(b, d.total) + b = append(b, d.mem[:d.n]...) + b = b[:len(b)+len(d.mem)-d.n] + return b, nil +} + +// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. +func (d *Digest) UnmarshalBinary(b []byte) error { + if len(b) < len(magic) || string(b[:len(magic)]) != magic { + return errors.New("xxhash: invalid hash state identifier") + } + if len(b) != marshaledSize { + return errors.New("xxhash: invalid hash state size") + } + b = b[len(magic):] + b, d.v1 = consumeUint64(b) + b, d.v2 = consumeUint64(b) + b, d.v3 = consumeUint64(b) + b, d.v4 = consumeUint64(b) + b, d.total = consumeUint64(b) + copy(d.mem[:], b) + d.n = int(d.total % uint64(len(d.mem))) + return nil +} + +func appendUint64(b []byte, x uint64) []byte { + var a [8]byte + binary.LittleEndian.PutUint64(a[:], x) + return append(b, a[:]...) +} + +func consumeUint64(b []byte) ([]byte, uint64) { + x := u64(b) + return b[8:], x +} + +func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) } +func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) } + +func round(acc, input uint64) uint64 { + acc += input * prime2 + acc = rol31(acc) + acc *= prime1 + return acc +} + +func mergeRound(acc, val uint64) uint64 { + val = round(0, val) + acc ^= val + acc = acc*prime1 + prime4 + return acc +} + +func rol1(x uint64) uint64 { return bits.RotateLeft64(x, 1) } +func rol7(x uint64) uint64 { return bits.RotateLeft64(x, 7) } +func rol11(x uint64) uint64 { return bits.RotateLeft64(x, 11) } +func rol12(x uint64) uint64 { return bits.RotateLeft64(x, 12) } +func rol18(x uint64) uint64 { return bits.RotateLeft64(x, 18) } +func rol23(x uint64) uint64 { return bits.RotateLeft64(x, 23) } +func rol27(x uint64) uint64 { return bits.RotateLeft64(x, 27) } +func rol31(x uint64) uint64 { return bits.RotateLeft64(x, 31) } diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s b/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s new file mode 100644 index 00000000..3e8b1325 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s @@ -0,0 +1,209 @@ +//go:build !appengine && gc && !purego +// +build !appengine +// +build gc +// +build !purego + +#include "textflag.h" + +// Registers: +#define h AX +#define d AX +#define p SI // pointer to advance through b +#define n DX +#define end BX // loop end +#define v1 R8 +#define v2 R9 +#define v3 R10 +#define v4 R11 +#define x R12 +#define prime1 R13 +#define prime2 R14 +#define prime4 DI + +#define round(acc, x) \ + IMULQ prime2, x \ + ADDQ x, acc \ + ROLQ $31, acc \ + IMULQ prime1, acc + +// round0 performs the operation x = round(0, x). +#define round0(x) \ + IMULQ prime2, x \ + ROLQ $31, x \ + IMULQ prime1, x + +// mergeRound applies a merge round on the two registers acc and x. +// It assumes that prime1, prime2, and prime4 have been loaded. +#define mergeRound(acc, x) \ + round0(x) \ + XORQ x, acc \ + IMULQ prime1, acc \ + ADDQ prime4, acc + +// blockLoop processes as many 32-byte blocks as possible, +// updating v1, v2, v3, and v4. It assumes that there is at least one block +// to process. +#define blockLoop() \ +loop: \ + MOVQ +0(p), x \ + round(v1, x) \ + MOVQ +8(p), x \ + round(v2, x) \ + MOVQ +16(p), x \ + round(v3, x) \ + MOVQ +24(p), x \ + round(v4, x) \ + ADDQ $32, p \ + CMPQ p, end \ + JLE loop + +// func Sum64(b []byte) uint64 +TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 + // Load fixed primes. + MOVQ ·primes+0(SB), prime1 + MOVQ ·primes+8(SB), prime2 + MOVQ ·primes+24(SB), prime4 + + // Load slice. + MOVQ b_base+0(FP), p + MOVQ b_len+8(FP), n + LEAQ (p)(n*1), end + + // The first loop limit will be len(b)-32. + SUBQ $32, end + + // Check whether we have at least one block. + CMPQ n, $32 + JLT noBlocks + + // Set up initial state (v1, v2, v3, v4). + MOVQ prime1, v1 + ADDQ prime2, v1 + MOVQ prime2, v2 + XORQ v3, v3 + XORQ v4, v4 + SUBQ prime1, v4 + + blockLoop() + + MOVQ v1, h + ROLQ $1, h + MOVQ v2, x + ROLQ $7, x + ADDQ x, h + MOVQ v3, x + ROLQ $12, x + ADDQ x, h + MOVQ v4, x + ROLQ $18, x + ADDQ x, h + + mergeRound(h, v1) + mergeRound(h, v2) + mergeRound(h, v3) + mergeRound(h, v4) + + JMP afterBlocks + +noBlocks: + MOVQ ·primes+32(SB), h + +afterBlocks: + ADDQ n, h + + ADDQ $24, end + CMPQ p, end + JG try4 + +loop8: + MOVQ (p), x + ADDQ $8, p + round0(x) + XORQ x, h + ROLQ $27, h + IMULQ prime1, h + ADDQ prime4, h + + CMPQ p, end + JLE loop8 + +try4: + ADDQ $4, end + CMPQ p, end + JG try1 + + MOVL (p), x + ADDQ $4, p + IMULQ prime1, x + XORQ x, h + + ROLQ $23, h + IMULQ prime2, h + ADDQ ·primes+16(SB), h + +try1: + ADDQ $4, end + CMPQ p, end + JGE finalize + +loop1: + MOVBQZX (p), x + ADDQ $1, p + IMULQ ·primes+32(SB), x + XORQ x, h + ROLQ $11, h + IMULQ prime1, h + + CMPQ p, end + JL loop1 + +finalize: + MOVQ h, x + SHRQ $33, x + XORQ x, h + IMULQ prime2, h + MOVQ h, x + SHRQ $29, x + XORQ x, h + IMULQ ·primes+16(SB), h + MOVQ h, x + SHRQ $32, x + XORQ x, h + + MOVQ h, ret+24(FP) + RET + +// func writeBlocks(d *Digest, b []byte) int +TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 + // Load fixed primes needed for round. + MOVQ ·primes+0(SB), prime1 + MOVQ ·primes+8(SB), prime2 + + // Load slice. + MOVQ b_base+8(FP), p + MOVQ b_len+16(FP), n + LEAQ (p)(n*1), end + SUBQ $32, end + + // Load vN from d. + MOVQ s+0(FP), d + MOVQ 0(d), v1 + MOVQ 8(d), v2 + MOVQ 16(d), v3 + MOVQ 24(d), v4 + + // We don't need to check the loop condition here; this function is + // always called with at least one block of data to process. + blockLoop() + + // Copy vN back to d. + MOVQ v1, 0(d) + MOVQ v2, 8(d) + MOVQ v3, 16(d) + MOVQ v4, 24(d) + + // The number of bytes written is p minus the old base pointer. + SUBQ b_base+8(FP), p + MOVQ p, ret+32(FP) + + RET diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s b/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s new file mode 100644 index 00000000..7e3145a2 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s @@ -0,0 +1,183 @@ +//go:build !appengine && gc && !purego +// +build !appengine +// +build gc +// +build !purego + +#include "textflag.h" + +// Registers: +#define digest R1 +#define h R2 // return value +#define p R3 // input pointer +#define n R4 // input length +#define nblocks R5 // n / 32 +#define prime1 R7 +#define prime2 R8 +#define prime3 R9 +#define prime4 R10 +#define prime5 R11 +#define v1 R12 +#define v2 R13 +#define v3 R14 +#define v4 R15 +#define x1 R20 +#define x2 R21 +#define x3 R22 +#define x4 R23 + +#define round(acc, x) \ + MADD prime2, acc, x, acc \ + ROR $64-31, acc \ + MUL prime1, acc + +// round0 performs the operation x = round(0, x). +#define round0(x) \ + MUL prime2, x \ + ROR $64-31, x \ + MUL prime1, x + +#define mergeRound(acc, x) \ + round0(x) \ + EOR x, acc \ + MADD acc, prime4, prime1, acc + +// blockLoop processes as many 32-byte blocks as possible, +// updating v1, v2, v3, and v4. It assumes that n >= 32. +#define blockLoop() \ + LSR $5, n, nblocks \ + PCALIGN $16 \ + loop: \ + LDP.P 16(p), (x1, x2) \ + LDP.P 16(p), (x3, x4) \ + round(v1, x1) \ + round(v2, x2) \ + round(v3, x3) \ + round(v4, x4) \ + SUB $1, nblocks \ + CBNZ nblocks, loop + +// func Sum64(b []byte) uint64 +TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 + LDP b_base+0(FP), (p, n) + + LDP ·primes+0(SB), (prime1, prime2) + LDP ·primes+16(SB), (prime3, prime4) + MOVD ·primes+32(SB), prime5 + + CMP $32, n + CSEL LT, prime5, ZR, h // if n < 32 { h = prime5 } else { h = 0 } + BLT afterLoop + + ADD prime1, prime2, v1 + MOVD prime2, v2 + MOVD $0, v3 + NEG prime1, v4 + + blockLoop() + + ROR $64-1, v1, x1 + ROR $64-7, v2, x2 + ADD x1, x2 + ROR $64-12, v3, x3 + ROR $64-18, v4, x4 + ADD x3, x4 + ADD x2, x4, h + + mergeRound(h, v1) + mergeRound(h, v2) + mergeRound(h, v3) + mergeRound(h, v4) + +afterLoop: + ADD n, h + + TBZ $4, n, try8 + LDP.P 16(p), (x1, x2) + + round0(x1) + + // NOTE: here and below, sequencing the EOR after the ROR (using a + // rotated register) is worth a small but measurable speedup for small + // inputs. + ROR $64-27, h + EOR x1 @> 64-27, h, h + MADD h, prime4, prime1, h + + round0(x2) + ROR $64-27, h + EOR x2 @> 64-27, h, h + MADD h, prime4, prime1, h + +try8: + TBZ $3, n, try4 + MOVD.P 8(p), x1 + + round0(x1) + ROR $64-27, h + EOR x1 @> 64-27, h, h + MADD h, prime4, prime1, h + +try4: + TBZ $2, n, try2 + MOVWU.P 4(p), x2 + + MUL prime1, x2 + ROR $64-23, h + EOR x2 @> 64-23, h, h + MADD h, prime3, prime2, h + +try2: + TBZ $1, n, try1 + MOVHU.P 2(p), x3 + AND $255, x3, x1 + LSR $8, x3, x2 + + MUL prime5, x1 + ROR $64-11, h + EOR x1 @> 64-11, h, h + MUL prime1, h + + MUL prime5, x2 + ROR $64-11, h + EOR x2 @> 64-11, h, h + MUL prime1, h + +try1: + TBZ $0, n, finalize + MOVBU (p), x4 + + MUL prime5, x4 + ROR $64-11, h + EOR x4 @> 64-11, h, h + MUL prime1, h + +finalize: + EOR h >> 33, h + MUL prime2, h + EOR h >> 29, h + MUL prime3, h + EOR h >> 32, h + + MOVD h, ret+24(FP) + RET + +// func writeBlocks(d *Digest, b []byte) int +TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 + LDP ·primes+0(SB), (prime1, prime2) + + // Load state. Assume v[1-4] are stored contiguously. + MOVD d+0(FP), digest + LDP 0(digest), (v1, v2) + LDP 16(digest), (v3, v4) + + LDP b_base+8(FP), (p, n) + + blockLoop() + + // Store updated state. + STP (v1, v2), 0(digest) + STP (v3, v4), 16(digest) + + BIC $31, n + MOVD n, ret+32(FP) + RET diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go b/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go new file mode 100644 index 00000000..78f95f25 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go @@ -0,0 +1,15 @@ +//go:build (amd64 || arm64) && !appengine && gc && !purego +// +build amd64 arm64 +// +build !appengine +// +build gc +// +build !purego + +package xxhash + +// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +// +//go:noescape +func Sum64(b []byte) uint64 + +//go:noescape +func writeBlocks(d *Digest, b []byte) int diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_other.go b/vendor/github.com/cespare/xxhash/v2/xxhash_other.go new file mode 100644 index 00000000..118e49e8 --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_other.go @@ -0,0 +1,76 @@ +//go:build (!amd64 && !arm64) || appengine || !gc || purego +// +build !amd64,!arm64 appengine !gc purego + +package xxhash + +// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +func Sum64(b []byte) uint64 { + // A simpler version would be + // d := New() + // d.Write(b) + // return d.Sum64() + // but this is faster, particularly for small inputs. + + n := len(b) + var h uint64 + + if n >= 32 { + v1 := primes[0] + prime2 + v2 := prime2 + v3 := uint64(0) + v4 := -primes[0] + for len(b) >= 32 { + v1 = round(v1, u64(b[0:8:len(b)])) + v2 = round(v2, u64(b[8:16:len(b)])) + v3 = round(v3, u64(b[16:24:len(b)])) + v4 = round(v4, u64(b[24:32:len(b)])) + b = b[32:len(b):len(b)] + } + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + } else { + h = prime5 + } + + h += uint64(n) + + for ; len(b) >= 8; b = b[8:] { + k1 := round(0, u64(b[:8])) + h ^= k1 + h = rol27(h)*prime1 + prime4 + } + if len(b) >= 4 { + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + } + for ; len(b) > 0; b = b[1:] { + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + } + + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} + +func writeBlocks(d *Digest, b []byte) int { + v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 + n := len(b) + for len(b) >= 32 { + v1 = round(v1, u64(b[0:8:len(b)])) + v2 = round(v2, u64(b[8:16:len(b)])) + v3 = round(v3, u64(b[16:24:len(b)])) + v4 = round(v4, u64(b[24:32:len(b)])) + b = b[32:len(b):len(b)] + } + d.v1, d.v2, d.v3, d.v4 = v1, v2, v3, v4 + return n - len(b) +} diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go new file mode 100644 index 00000000..05f5e7df --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go @@ -0,0 +1,16 @@ +//go:build appengine +// +build appengine + +// This file contains the safe implementations of otherwise unsafe-using code. + +package xxhash + +// Sum64String computes the 64-bit xxHash digest of s with a zero seed. +func Sum64String(s string) uint64 { + return Sum64([]byte(s)) +} + +// WriteString adds more data to d. It always returns len(s), nil. +func (d *Digest) WriteString(s string) (n int, err error) { + return d.Write([]byte(s)) +} diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go new file mode 100644 index 00000000..cf9d42ae --- /dev/null +++ b/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go @@ -0,0 +1,58 @@ +//go:build !appengine +// +build !appengine + +// This file encapsulates usage of unsafe. +// xxhash_safe.go contains the safe implementations. + +package xxhash + +import ( + "unsafe" +) + +// In the future it's possible that compiler optimizations will make these +// XxxString functions unnecessary by realizing that calls such as +// Sum64([]byte(s)) don't need to copy s. See https://go.dev/issue/2205. +// If that happens, even if we keep these functions they can be replaced with +// the trivial safe code. + +// NOTE: The usual way of doing an unsafe string-to-[]byte conversion is: +// +// var b []byte +// bh := (*reflect.SliceHeader)(unsafe.Pointer(&b)) +// bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data +// bh.Len = len(s) +// bh.Cap = len(s) +// +// Unfortunately, as of Go 1.15.3 the inliner's cost model assigns a high enough +// weight to this sequence of expressions that any function that uses it will +// not be inlined. Instead, the functions below use a different unsafe +// conversion designed to minimize the inliner weight and allow both to be +// inlined. There is also a test (TestInlining) which verifies that these are +// inlined. +// +// See https://github.com/golang/go/issues/42739 for discussion. + +// Sum64String computes the 64-bit xxHash digest of s with a zero seed. +// It may be faster than Sum64([]byte(s)) by avoiding a copy. +func Sum64String(s string) uint64 { + b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})) + return Sum64(b) +} + +// WriteString adds more data to d. It always returns len(s), nil. +// It may be faster than Write([]byte(s)) by avoiding a copy. +func (d *Digest) WriteString(s string) (n int, err error) { + d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))) + // d.Write always returns len(s), nil. + // Ignoring the return output and returning these fixed values buys a + // savings of 6 in the inliner's cost model. + return len(s), nil +} + +// sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout +// of the first two words is the same as the layout of a string. +type sliceHeader struct { + s string + cap int +} diff --git a/vendor/github.com/clipperhouse/stringish/.gitignore b/vendor/github.com/clipperhouse/displaywidth/.gitignore similarity index 73% rename from vendor/github.com/clipperhouse/stringish/.gitignore rename to vendor/github.com/clipperhouse/displaywidth/.gitignore index 12fbfb73..b356d43c 100644 --- a/vendor/github.com/clipperhouse/stringish/.gitignore +++ b/vendor/github.com/clipperhouse/displaywidth/.gitignore @@ -1,2 +1,3 @@ .DS_Store +*.out *.test diff --git a/vendor/github.com/clipperhouse/displaywidth/AGENTS.md b/vendor/github.com/clipperhouse/displaywidth/AGENTS.md new file mode 100644 index 00000000..9ae951b2 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/AGENTS.md @@ -0,0 +1,51 @@ +The goals and overview of this package can be found in the README.md file, +start by reading that. + +The goal of this package is to determine the display (column) width of a +string, UTF-8 bytes, or runes, as would happen in a monospace font, especially +in a terminal. + +When troubleshooting, write Go unit tests instead of executing debug scripts. +The tests can return whatever logs or output you need. If those tests are +only for temporary troubleshooting, clean up the tests after the debugging is +done. + +(Separate executable debugging scripts are messy, tend to have conflicting +dependencies and are hard to cleanup.) + +If you make changes to the trie generation in internal/gen, it can be invoked +by running `go generate` from the top package directory. + +## Pull Requests and branches + +For PRs (pull requests), you can use the gh CLI tool. Compare the current branch with main. Reviewing a PR and reviewing a branch are about the same, but the PR may add context. + +Understand the goals of the PR. Note any API changes, especially breaking changes. + +Look for thoroughness of tests, as well as GoDoc comments. + +Retrieve and consider the comments on the PR, which may have come from GitHub Copilot or Cursor BugBot. Think like GitHub Copilot or Cursor BugBot. + +Offer to optionally post a brief summary of the review to the PR, via the gh CLI tool. + +## Tagged Go releases + +If I ask you whether we are ready to release, this means a tagged Go release on the main branch. Go releases are git tagged with a version number. + +Review the changes since the last release, i.e. the previous git tag. Ensure that the changes are complete and correct. Identify new features, bug fixes, and performance improvements. + +Identify breaking changes, especially API changes. + +Ensure good test coverage. Look for performance changes, especially performance regressions, by running benchmarks against the previous release. + +Ensure that the documentation in READMEs and GoDocs are complete, correct and consistent. + +## Comparisons to go-runewidth + +We originally attempted to make this package compatible with go-runewidth. +However, we found that there were too many differences in the handling of +certain characters and properties. + +We believe, preliminarily, that our choices are more correct and complete, +by using more complete categories such as Unicode Cf (format) for zero-width +and Mn (Nonspacing_Mark) for combining marks. diff --git a/vendor/github.com/clipperhouse/displaywidth/CHANGELOG.md b/vendor/github.com/clipperhouse/displaywidth/CHANGELOG.md new file mode 100644 index 00000000..8c6efc10 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/CHANGELOG.md @@ -0,0 +1,129 @@ +# Changelog + +## [0.11.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.10.0...v0.11.0) + +### Added +- New `ControlSequences8Bit` option to treat 8-bit ECMA-48 (C1) escape sequences as zero-width. (#22) + +### Changed +- Upgraded uax29 dependency to v2.7.0 for 8-bit escape sequence support in the grapheme iterator. +- Truncation now validates that preserved trailing escape sequences are zero-width, preventing edge cases where non-zero-width sequences could leak into output. + +### Note +- `ControlSequences8Bit` is deliberately ignored by `TruncateString` and `TruncateBytes`, because C1 byte values (0x80–0x9F) overlap with UTF-8 multi-byte encoding. + +## [0.10.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.9.0...v0.10.0) + +### Added +- New `ControlSequences` option to treat ECMA-48/ANSI escape sequences as zero-width. (#20) +- `TruncateString` and `TruncateBytes` now preserve trailing ANSI escape sequences (such as SGR resets) when `ControlSequences` is true, preventing color bleed in terminal output. + +### Changed +- Removed `stringish` dependency; generic type constraints are now inline `~string | []byte`. +- Upgraded uax29 dependency to v2.6.0 for ANSI escape sequence support in the grapheme iterator. + +## [0.9.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.8.0...v0.9.0) + +### Changed +- Unicode 17 support: East Asian Width and emoji data updated to Unicode 17.0.0. (#18) +- Upgraded uax29 dependency to v2.5.0 (Unicode 17 grapheme segmentation). + +## [0.8.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.7.0...v0.8.0) + +### Changed +- Performance: ASCII fast path that applies to any run of printable + ASCII. 2x-10x faster for ASCII text vs v0.7.0. (#16) +- Upgraded uax29 dependency to v2.4.0 for Unicode 16 support. Text that includes + Indic_Conjunct_Break may segment differently (and more correctly). (#15) + +## [0.7.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.6.2...v0.7.0) + +### Added +- New `TruncateString` and `TruncateBytes` methods to truncate strings to a + maximum display width, with optional tail (like an ellipsis). (#13) + +## [0.6.2] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.6.1...v0.6.2) + +### Changed +- Internal: reduced property categories for simpler trie. + +## [0.6.1] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.6.0...v0.6.1) + +### Changed +- Perf improvements: replaced the ASCII lookup table with a simple + function. A bit more cache-friendly. More inlining. +- Bug fix: single regional indicators are now treated as width 2, since that + is what actual terminals do. + +## [0.6.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.5.0...v0.6.0) + +### Added +- New `StringGraphemes` and `BytesGraphemes` methods, for iterating over the +widths of grapheme clusters. + +### Changed +- Fast ASCII lookups + +## [0.5.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.4.1...v0.5.0) + +### Added +- Unicode 16 support +- Improved emoji presentation handling per Unicode TR51 + +### Changed +- Corrected VS15 (U+FE0E) handling: now preserves base character width (no-op) per Unicode TR51 +- Performance optimizations: reduced property lookups + +### Fixed +- VS15 variation selector now correctly preserves base character width instead of forcing width 1 + +## [0.4.1] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.4.0...v0.4.1) + +### Changed +- Updated uax29 dependency +- Improved flag handling + +## [0.4.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.3.1...v0.4.0) + +### Added +- Support for variation selectors (VS15, VS16) and regional indicator pairs (flags) + +## [0.3.1] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.3.0...v0.3.1) + +### Added +- Fuzz testing support + +### Changed +- Updated stringish dependency + +## [0.3.0] + +[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.2.0...v0.3.0) + +### Changed +- Dropped compatibility with go-runewidth +- Trie implementation cleanup diff --git a/vendor/github.com/clipperhouse/stringish/LICENSE b/vendor/github.com/clipperhouse/displaywidth/LICENSE similarity index 100% rename from vendor/github.com/clipperhouse/stringish/LICENSE rename to vendor/github.com/clipperhouse/displaywidth/LICENSE diff --git a/vendor/github.com/clipperhouse/displaywidth/README.md b/vendor/github.com/clipperhouse/displaywidth/README.md new file mode 100644 index 00000000..506822b0 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/README.md @@ -0,0 +1,190 @@ +# displaywidth + +A high-performance Go package for measuring the monospace display width of strings, UTF-8 bytes, and runes. + +[![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/displaywidth.svg)](https://pkg.go.dev/github.com/clipperhouse/displaywidth) +[![Test](https://github.com/clipperhouse/displaywidth/actions/workflows/gotest.yml/badge.svg)](https://github.com/clipperhouse/displaywidth/actions/workflows/gotest.yml) +[![Fuzz](https://github.com/clipperhouse/displaywidth/actions/workflows/gofuzz.yml/badge.svg)](https://github.com/clipperhouse/displaywidth/actions/workflows/gofuzz.yml) + +## Install +```bash +go get github.com/clipperhouse/displaywidth +``` + +## Usage + +```go +package main + +import ( + "fmt" + "github.com/clipperhouse/displaywidth" +) + +func main() { + width := displaywidth.String("Hello, 世界!") + fmt.Println(width) + + width = displaywidth.Bytes([]byte("🌍")) + fmt.Println(width) + + width = displaywidth.Rune('🌍') + fmt.Println(width) +} +``` + +For most purposes, you should use the `String` or `Bytes` methods. They sum +the widths of grapheme clusters in the string or byte slice. + +> Note: in your application, iterating over runes to measure width is likely incorrect; +the smallest unit of display is a grapheme, not a rune. + +### Iterating over graphemes + +If you need the individual graphemes: + +```go +import ( + "fmt" + "github.com/clipperhouse/displaywidth" +) + +func main() { + g := displaywidth.StringGraphemes("Hello, 世界!") + for g.Next() { + width := g.Width() + value := g.Value() + // do something with the width or value + } +} +``` + +### Options + +Create the options you need, and then use methods on the options struct. + +```go +var myOptions = displaywidth.Options{ + EastAsianWidth: true, + ControlSequences: true, +} + +width := myOptions.String("Hello, 世界!") +``` + +#### ControlSequences + +`ControlSequences` specifies whether to ignore ECMA-48 escape sequences +when calculating the display width. When `false` (default), ANSI escape +sequences are treated as just a series of characters. When `true`, they are +treated as a single zero-width unit. + +#### ControlSequences8Bit + +`ControlSequences8Bit` specifies whether to ignore 8-bit ECMA-48 escape sequences +when calculating the display width. When `false` (default), these are treated +as just a series of characters. When `true`, they are treated as a single +zero-width unit. + +Note: this option is ignored by the `Truncate` methods, as the concatenation +can lead to unintended UTF-8 semantics. + +#### EastAsianWidth + +`EastAsianWidth` defines how +[East Asian Ambiguous characters](https://www.unicode.org/reports/tr11/#Ambiguous) +are treated. + +When `false` (default), East Asian Ambiguous characters are treated as width 1. +When `true`, they are treated as width 2. + +You may wish to configure this based on environment variables or locale. + `go-runewidth`, for example, does so + [during package initialization](https://github.com/mattn/go-runewidth/blob/master/runewidth.go#L26C1-L45C2). `displaywidth` does not do this automatically, we prefer to leave it to you. + + +## Technical standards and compatibility + +This package implements the Unicode East Asian Width standard +([UAX #11](https://www.unicode.org/reports/tr11/tr11-43.html)), and handles +[version selectors](https://en.wikipedia.org/wiki/Variation_Selectors_(Unicode_block)), +and [regional indicator pairs](https://en.wikipedia.org/wiki/Regional_indicator_symbol) +(flags). We implement [Unicode TR51](https://www.unicode.org/reports/tr51/tr51-27.html) +for emojis. We are keeping an eye on +[emerging standards](https://www.jeffquast.com/post/state-of-terminal-emulation-2025/). + +For control sequences, we implement the [ECMA-48](https://ecma-international.org/publications-and-standards/standards/ecma-48/) standard for 7-bit and 8-bit control sequences. + +`clipperhouse/displaywidth`, `mattn/go-runewidth`, and `rivo/uniseg` will +give the same outputs for most real-world text. Extensive details are in the +[compatibility analysis](comparison/COMPATIBILITY_ANALYSIS.md). + +## Invalid UTF-8 + +This package does not validate UTF-8. If you pass invalid UTF-8, the results +are undefined. We fuzz against invalid UTF-8 to ensure we don't panic or +loop indefinitely. + +The `ControlSequences8Bit` option means that we will segment valid 8-bit +control sequences, which are typically _not_ valid UTF-8. 8-bit control bytes +happen to also be UTF-8 continuation bytes. Use with caution. + +## Prior Art + +[mattn/go-runewidth](https://github.com/mattn/go-runewidth) + +[rivo/uniseg](https://github.com/rivo/uniseg) + +[x/text/width](https://pkg.go.dev/golang.org/x/text/width) + +[x/text/internal/triegen](https://pkg.go.dev/golang.org/x/text/internal/triegen) + +## Benchmarks + +```bash +cd comparison +go test -bench=. -benchmem +``` + +``` +goos: darwin +goarch: arm64 +pkg: github.com/clipperhouse/displaywidth/comparison +cpu: Apple M2 + +BenchmarkString_Mixed/clipperhouse/displaywidth-8 5784 ns/op 291.69 MB/s 0 B/op 0 allocs/op +BenchmarkString_Mixed/mattn/go-runewidth-8 14751 ns/op 114.36 MB/s 0 B/op 0 allocs/op +BenchmarkString_Mixed/rivo/uniseg-8 19360 ns/op 87.14 MB/s 0 B/op 0 allocs/op + +BenchmarkString_ASCII/clipperhouse/displaywidth-8 54.60 ns/op 2344.32 MB/s 0 B/op 0 allocs/op +BenchmarkString_ASCII/mattn/go-runewidth-8 1195 ns/op 107.08 MB/s 0 B/op 0 allocs/op +BenchmarkString_ASCII/rivo/uniseg-8 1578 ns/op 81.13 MB/s 0 B/op 0 allocs/op + +BenchmarkString_EastAsian/clipperhouse/displaywidth-8 5837 ns/op 289.01 MB/s 0 B/op 0 allocs/op +BenchmarkString_EastAsian/mattn/go-runewidth-8 24418 ns/op 69.09 MB/s 0 B/op 0 allocs/op +BenchmarkString_EastAsian/rivo/uniseg-8 19339 ns/op 87.23 MB/s 0 B/op 0 allocs/op + +BenchmarkString_Emoji/clipperhouse/displaywidth-8 3225 ns/op 224.51 MB/s 0 B/op 0 allocs/op +BenchmarkString_Emoji/mattn/go-runewidth-8 4851 ns/op 149.25 MB/s 0 B/op 0 allocs/op +BenchmarkString_Emoji/rivo/uniseg-8 6591 ns/op 109.85 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_Mixed/clipperhouse/displaywidth-8 3385 ns/op 498.34 MB/s 0 B/op 0 allocs/op +BenchmarkRune_Mixed/mattn/go-runewidth-8 5354 ns/op 315.07 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_EastAsian/clipperhouse/displaywidth-8 3397 ns/op 496.56 MB/s 0 B/op 0 allocs/op +BenchmarkRune_EastAsian/mattn/go-runewidth-8 15673 ns/op 107.64 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_ASCII/clipperhouse/displaywidth-8 255.7 ns/op 500.53 MB/s 0 B/op 0 allocs/op +BenchmarkRune_ASCII/mattn/go-runewidth-8 261.5 ns/op 489.55 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_Emoji/clipperhouse/displaywidth-8 1371 ns/op 528.22 MB/s 0 B/op 0 allocs/op +BenchmarkRune_Emoji/mattn/go-runewidth-8 2267 ns/op 319.43 MB/s 0 B/op 0 allocs/op + +BenchmarkTruncateWithTail/clipperhouse/displaywidth-8 3229 ns/op 54.82 MB/s 192 B/op 14 allocs/op +BenchmarkTruncateWithTail/mattn/go-runewidth-8 8408 ns/op 21.05 MB/s 192 B/op 14 allocs/op + +BenchmarkTruncateWithoutTail/clipperhouse/displaywidth-8 3554 ns/op 64.43 MB/s 0 B/op 0 allocs/op +BenchmarkTruncateWithoutTail/mattn/go-runewidth-8 11189 ns/op 20.47 MB/s 0 B/op 0 allocs/op +``` + +Here are some notes on [how to make Unicode things fast](https://clipperhouse.com/go-unicode/). diff --git a/vendor/github.com/clipperhouse/displaywidth/gen.go b/vendor/github.com/clipperhouse/displaywidth/gen.go new file mode 100644 index 00000000..52e1085b --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/gen.go @@ -0,0 +1,3 @@ +package displaywidth + +//go:generate go run -C internal/gen . diff --git a/vendor/github.com/clipperhouse/displaywidth/graphemes.go b/vendor/github.com/clipperhouse/displaywidth/graphemes.go new file mode 100644 index 00000000..14a52788 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/graphemes.go @@ -0,0 +1,73 @@ +package displaywidth + +import ( + "github.com/clipperhouse/uax29/v2/graphemes" +) + +// Graphemes is an iterator over grapheme clusters. +// +// Iterate using the Next method, and get the width of the current grapheme +// using the Width method. +type Graphemes[T ~string | []byte] struct { + iter *graphemes.Iterator[T] + options Options +} + +// Next advances the iterator to the next grapheme cluster. +func (g *Graphemes[T]) Next() bool { + return g.iter.Next() +} + +// Value returns the current grapheme cluster. +func (g *Graphemes[T]) Value() T { + return g.iter.Value() +} + +// Width returns the display width of the current grapheme cluster. +func (g *Graphemes[T]) Width() int { + return graphemeWidth(g.Value(), g.options) +} + +// StringGraphemes returns an iterator over grapheme clusters for the given +// string. +// +// Iterate using the Next method, and get the width of the current grapheme +// using the Width method. +func StringGraphemes(s string) Graphemes[string] { + return DefaultOptions.StringGraphemes(s) +} + +// StringGraphemes returns an iterator over grapheme clusters for the given +// string, with the given options. +// +// Iterate using the Next method, and get the width of the current grapheme +// using the Width method. +func (options Options) StringGraphemes(s string) Graphemes[string] { + g := graphemes.FromString(s) + g.AnsiEscapeSequences = options.ControlSequences + g.AnsiEscapeSequences8Bit = options.ControlSequences8Bit + + return Graphemes[string]{iter: g, options: options} +} + +// BytesGraphemes returns an iterator over grapheme clusters for the given +// []byte. +// +// Iterate using the Next method, and get the width of the current grapheme +// using the Width method. +func BytesGraphemes(s []byte) Graphemes[[]byte] { + return DefaultOptions.BytesGraphemes(s) +} + +// BytesGraphemes returns an iterator over grapheme clusters for the given +// []byte, with the given options. +// +// Iterate using the Next method, and get the width of the current grapheme +// using the Width method. +func (options Options) BytesGraphemes(s []byte) Graphemes[[]byte] { + g := graphemes.FromBytes(s) + g.AnsiEscapeSequences = options.ControlSequences + g.AnsiEscapeSequences8Bit = options.ControlSequences8Bit + + return Graphemes[[]byte]{iter: g, options: options} +} diff --git a/vendor/github.com/clipperhouse/displaywidth/options.go b/vendor/github.com/clipperhouse/displaywidth/options.go new file mode 100644 index 00000000..b63b585a --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/options.go @@ -0,0 +1,30 @@ +package displaywidth + +// Options allows you to specify the treatment of ambiguous East Asian +// characters and ANSI escape sequences. +type Options struct { + // EastAsianWidth specifies whether to treat ambiguous East Asian characters + // as width 1 or 2. When false (default), ambiguous East Asian characters + // are treated as width 1. When true, they are width 2. + EastAsianWidth bool + + // ControlSequences specifies whether to ignore 7-bit ECMA-48 escape sequences + // when calculating the display width. When false (default), ANSI escape + // sequences are treated as just a series of characters. When true, they are + // treated as a single zero-width unit. + ControlSequences bool + // ControlSequences8Bit specifies whether to ignore 8-bit ECMA-48 escape sequences + // when calculating the display width. When false (default), these are treated + // as just a series of characters. When true, they are treated as a single + // zero-width unit. + ControlSequences8Bit bool +} + +// DefaultOptions is the default options for the display width +// calculation, which is EastAsianWidth false, ControlSequences false, and +// ControlSequences8Bit false. +var DefaultOptions = Options{ + EastAsianWidth: false, + ControlSequences: false, + ControlSequences8Bit: false, +} diff --git a/vendor/github.com/clipperhouse/displaywidth/trie.go b/vendor/github.com/clipperhouse/displaywidth/trie.go new file mode 100644 index 00000000..1d3a9830 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/trie.go @@ -0,0 +1,1699 @@ +// Code generated by internal/gen/main.go. DO NOT EDIT. + +package displaywidth + +// property is an enum representing the properties of a character +type property uint8 + +const ( + // Always 0 width, includes combining marks, control characters, non-printable, etc + _Zero_Width property = iota + 1 + // Always 2 wide (East Asian Wide F/W, Emoji, Regional Indicator) + _Wide + // Width depends on EastAsianWidth option + _East_Asian_Ambiguous +) + +// lookup returns the trie value for the first UTF-8 encoding in s and +// the width in bytes of this encoding. The size will be 0 if s does not +// hold enough bytes to complete the encoding. len(s) must be greater than 0. +func lookup[T ~string | []byte](s T) (v uint8, sz int) { + c0 := s[0] + switch { + case c0 < 0x80: // is ASCII + return stringWidthValues[c0], 1 + case c0 < 0xC2: + return 0, 1 // Illegal UTF-8: not a starter, not ASCII. + case c0 < 0xE0: // 2-byte UTF-8 + if len(s) < 2 { + return 0, 0 + } + i := stringWidthIndex[c0] + c1 := s[1] + if c1 < 0x80 || 0xC0 <= c1 { + return 0, 1 // Illegal UTF-8: not a continuation byte. + } + return lookupValue(uint32(i), c1), 2 + case c0 < 0xF0: // 3-byte UTF-8 + if len(s) < 3 { + return 0, 0 + } + i := stringWidthIndex[c0] + c1 := s[1] + if c1 < 0x80 || 0xC0 <= c1 { + return 0, 1 // Illegal UTF-8: not a continuation byte. + } + o := uint32(i)<<6 + uint32(c1) + i = stringWidthIndex[o] + c2 := s[2] + if c2 < 0x80 || 0xC0 <= c2 { + return 0, 2 // Illegal UTF-8: not a continuation byte. + } + return lookupValue(uint32(i), c2), 3 + case c0 < 0xF8: // 4-byte UTF-8 + if len(s) < 4 { + return 0, 0 + } + i := stringWidthIndex[c0] + c1 := s[1] + if c1 < 0x80 || 0xC0 <= c1 { + return 0, 1 // Illegal UTF-8: not a continuation byte. + } + o := uint32(i)<<6 + uint32(c1) + i = stringWidthIndex[o] + c2 := s[2] + if c2 < 0x80 || 0xC0 <= c2 { + return 0, 2 // Illegal UTF-8: not a continuation byte. + } + o = uint32(i)<<6 + uint32(c2) + i = stringWidthIndex[o] + c3 := s[3] + if c3 < 0x80 || 0xC0 <= c3 { + return 0, 3 // Illegal UTF-8: not a continuation byte. + } + return lookupValue(uint32(i), c3), 4 + } + // Illegal rune + return 0, 1 +} + +// stringWidthTrie. Total size: 17664 bytes (17.25 KiB). Checksum: 220983462f26d765. +// type stringWidthTrie struct { } + +// func newStringWidthTrie(i int) *stringWidthTrie { +// return &stringWidthTrie{} +// } + +// lookupValue determines the type of block n and looks up the value for b. +func lookupValue(n uint32, b byte) uint8 { + switch { + default: + return uint8(stringWidthValues[n<<6+uint32(b)]) + } +} + +// stringWidthValues: 246 blocks, 15744 entries, 15744 bytes +// The third block is the zero block. +var stringWidthValues = [15744]uint8{ + // Block 0x0, offset 0x0 + // Block 0x1, offset 0x40 + // Block 0x2, offset 0x80 + // Block 0x3, offset 0xc0 + 0xc0: 0x0001, 0xc1: 0x0001, 0xc2: 0x0001, 0xc3: 0x0001, 0xc4: 0x0001, 0xc5: 0x0001, + 0xc6: 0x0001, 0xc7: 0x0001, 0xc8: 0x0001, 0xc9: 0x0001, 0xca: 0x0001, 0xcb: 0x0001, + 0xcc: 0x0001, 0xcd: 0x0001, 0xce: 0x0001, 0xcf: 0x0001, 0xd0: 0x0001, 0xd1: 0x0001, + 0xd2: 0x0001, 0xd3: 0x0001, 0xd4: 0x0001, 0xd5: 0x0001, 0xd6: 0x0001, 0xd7: 0x0001, + 0xd8: 0x0001, 0xd9: 0x0001, 0xda: 0x0001, 0xdb: 0x0001, 0xdc: 0x0001, 0xdd: 0x0001, + 0xde: 0x0001, 0xdf: 0x0001, 0xe1: 0x0003, + 0xe4: 0x0003, 0xe7: 0x0003, 0xe8: 0x0003, + 0xea: 0x0003, 0xed: 0x0001, 0xee: 0x0003, + 0xf0: 0x0003, 0xf1: 0x0003, 0xf2: 0x0003, 0xf3: 0x0003, 0xf4: 0x0003, + 0xf6: 0x0003, 0xf7: 0x0003, 0xf8: 0x0003, 0xf9: 0x0003, 0xfa: 0x0003, + 0xfc: 0x0003, 0xfd: 0x0003, 0xfe: 0x0003, 0xff: 0x0003, + // Block 0x4, offset 0x100 + 0x106: 0x0003, + 0x110: 0x0003, + 0x117: 0x0003, + 0x118: 0x0003, + 0x11e: 0x0003, 0x11f: 0x0003, 0x120: 0x0003, 0x121: 0x0003, + 0x126: 0x0003, 0x128: 0x0003, 0x129: 0x0003, + 0x12a: 0x0003, 0x12c: 0x0003, 0x12d: 0x0003, + 0x130: 0x0003, 0x132: 0x0003, 0x133: 0x0003, + 0x137: 0x0003, 0x138: 0x0003, 0x139: 0x0003, 0x13a: 0x0003, + 0x13c: 0x0003, 0x13e: 0x0003, + // Block 0x5, offset 0x140 + 0x141: 0x0003, + 0x151: 0x0003, + 0x153: 0x0003, + 0x15b: 0x0003, + 0x166: 0x0003, 0x167: 0x0003, + 0x16b: 0x0003, + 0x171: 0x0003, 0x172: 0x0003, 0x173: 0x0003, + 0x178: 0x0003, + 0x17f: 0x0003, + // Block 0x6, offset 0x180 + 0x180: 0x0003, 0x181: 0x0003, 0x182: 0x0003, 0x184: 0x0003, + 0x188: 0x0003, 0x189: 0x0003, 0x18a: 0x0003, 0x18b: 0x0003, + 0x18d: 0x0003, + 0x192: 0x0003, 0x193: 0x0003, + 0x1a6: 0x0003, 0x1a7: 0x0003, + 0x1ab: 0x0003, + // Block 0x7, offset 0x1c0 + 0x1ce: 0x0003, 0x1d0: 0x0003, + 0x1d2: 0x0003, 0x1d4: 0x0003, 0x1d6: 0x0003, + 0x1d8: 0x0003, 0x1da: 0x0003, 0x1dc: 0x0003, + // Block 0x8, offset 0x200 + 0x211: 0x0003, + 0x221: 0x0003, + // Block 0x9, offset 0x240 + 0x244: 0x0003, + 0x247: 0x0003, 0x249: 0x0003, 0x24a: 0x0003, 0x24b: 0x0003, + 0x24d: 0x0003, 0x250: 0x0003, + 0x258: 0x0003, 0x259: 0x0003, 0x25a: 0x0003, 0x25b: 0x0003, 0x25d: 0x0003, + 0x25f: 0x0003, + // Block 0xa, offset 0x280 + 0x280: 0x0001, 0x281: 0x0001, 0x282: 0x0001, 0x283: 0x0001, 0x284: 0x0001, 0x285: 0x0001, + 0x286: 0x0001, 0x287: 0x0001, 0x288: 0x0001, 0x289: 0x0001, 0x28a: 0x0001, 0x28b: 0x0001, + 0x28c: 0x0001, 0x28d: 0x0001, 0x28e: 0x0001, 0x28f: 0x0001, 0x290: 0x0001, 0x291: 0x0001, + 0x292: 0x0001, 0x293: 0x0001, 0x294: 0x0001, 0x295: 0x0001, 0x296: 0x0001, 0x297: 0x0001, + 0x298: 0x0001, 0x299: 0x0001, 0x29a: 0x0001, 0x29b: 0x0001, 0x29c: 0x0001, 0x29d: 0x0001, + 0x29e: 0x0001, 0x29f: 0x0001, 0x2a0: 0x0001, 0x2a1: 0x0001, 0x2a2: 0x0001, 0x2a3: 0x0001, + 0x2a4: 0x0001, 0x2a5: 0x0001, 0x2a6: 0x0001, 0x2a7: 0x0001, 0x2a8: 0x0001, 0x2a9: 0x0001, + 0x2aa: 0x0001, 0x2ab: 0x0001, 0x2ac: 0x0001, 0x2ad: 0x0001, 0x2ae: 0x0001, 0x2af: 0x0001, + 0x2b0: 0x0001, 0x2b1: 0x0001, 0x2b2: 0x0001, 0x2b3: 0x0001, 0x2b4: 0x0001, 0x2b5: 0x0001, + 0x2b6: 0x0001, 0x2b7: 0x0001, 0x2b8: 0x0001, 0x2b9: 0x0001, 0x2ba: 0x0001, 0x2bb: 0x0001, + 0x2bc: 0x0001, 0x2bd: 0x0001, 0x2be: 0x0001, 0x2bf: 0x0001, + // Block 0xb, offset 0x2c0 + 0x2c0: 0x0001, 0x2c1: 0x0001, 0x2c2: 0x0001, 0x2c3: 0x0001, 0x2c4: 0x0001, 0x2c5: 0x0001, + 0x2c6: 0x0001, 0x2c7: 0x0001, 0x2c8: 0x0001, 0x2c9: 0x0001, 0x2ca: 0x0001, 0x2cb: 0x0001, + 0x2cc: 0x0001, 0x2cd: 0x0001, 0x2ce: 0x0001, 0x2cf: 0x0001, 0x2d0: 0x0001, 0x2d1: 0x0001, + 0x2d2: 0x0001, 0x2d3: 0x0001, 0x2d4: 0x0001, 0x2d5: 0x0001, 0x2d6: 0x0001, 0x2d7: 0x0001, + 0x2d8: 0x0001, 0x2d9: 0x0001, 0x2da: 0x0001, 0x2db: 0x0001, 0x2dc: 0x0001, 0x2dd: 0x0001, + 0x2de: 0x0001, 0x2df: 0x0001, 0x2e0: 0x0001, 0x2e1: 0x0001, 0x2e2: 0x0001, 0x2e3: 0x0001, + 0x2e4: 0x0001, 0x2e5: 0x0001, 0x2e6: 0x0001, 0x2e7: 0x0001, 0x2e8: 0x0001, 0x2e9: 0x0001, + 0x2ea: 0x0001, 0x2eb: 0x0001, 0x2ec: 0x0001, 0x2ed: 0x0001, 0x2ee: 0x0001, 0x2ef: 0x0001, + // Block 0xc, offset 0x300 + 0x311: 0x0003, + 0x312: 0x0003, 0x313: 0x0003, 0x314: 0x0003, 0x315: 0x0003, 0x316: 0x0003, 0x317: 0x0003, + 0x318: 0x0003, 0x319: 0x0003, 0x31a: 0x0003, 0x31b: 0x0003, 0x31c: 0x0003, 0x31d: 0x0003, + 0x31e: 0x0003, 0x31f: 0x0003, 0x320: 0x0003, 0x321: 0x0003, 0x323: 0x0003, + 0x324: 0x0003, 0x325: 0x0003, 0x326: 0x0003, 0x327: 0x0003, 0x328: 0x0003, 0x329: 0x0003, + 0x331: 0x0003, 0x332: 0x0003, 0x333: 0x0003, 0x334: 0x0003, 0x335: 0x0003, + 0x336: 0x0003, 0x337: 0x0003, 0x338: 0x0003, 0x339: 0x0003, 0x33a: 0x0003, 0x33b: 0x0003, + 0x33c: 0x0003, 0x33d: 0x0003, 0x33e: 0x0003, 0x33f: 0x0003, + // Block 0xd, offset 0x340 + 0x340: 0x0003, 0x341: 0x0003, 0x343: 0x0003, 0x344: 0x0003, 0x345: 0x0003, + 0x346: 0x0003, 0x347: 0x0003, 0x348: 0x0003, 0x349: 0x0003, + // Block 0xe, offset 0x380 + 0x381: 0x0003, + 0x390: 0x0003, 0x391: 0x0003, + 0x392: 0x0003, 0x393: 0x0003, 0x394: 0x0003, 0x395: 0x0003, 0x396: 0x0003, 0x397: 0x0003, + 0x398: 0x0003, 0x399: 0x0003, 0x39a: 0x0003, 0x39b: 0x0003, 0x39c: 0x0003, 0x39d: 0x0003, + 0x39e: 0x0003, 0x39f: 0x0003, 0x3a0: 0x0003, 0x3a1: 0x0003, 0x3a2: 0x0003, 0x3a3: 0x0003, + 0x3a4: 0x0003, 0x3a5: 0x0003, 0x3a6: 0x0003, 0x3a7: 0x0003, 0x3a8: 0x0003, 0x3a9: 0x0003, + 0x3aa: 0x0003, 0x3ab: 0x0003, 0x3ac: 0x0003, 0x3ad: 0x0003, 0x3ae: 0x0003, 0x3af: 0x0003, + 0x3b0: 0x0003, 0x3b1: 0x0003, 0x3b2: 0x0003, 0x3b3: 0x0003, 0x3b4: 0x0003, 0x3b5: 0x0003, + 0x3b6: 0x0003, 0x3b7: 0x0003, 0x3b8: 0x0003, 0x3b9: 0x0003, 0x3ba: 0x0003, 0x3bb: 0x0003, + 0x3bc: 0x0003, 0x3bd: 0x0003, 0x3be: 0x0003, 0x3bf: 0x0003, + // Block 0xf, offset 0x3c0 + 0x3c0: 0x0003, 0x3c1: 0x0003, 0x3c2: 0x0003, 0x3c3: 0x0003, 0x3c4: 0x0003, 0x3c5: 0x0003, + 0x3c6: 0x0003, 0x3c7: 0x0003, 0x3c8: 0x0003, 0x3c9: 0x0003, 0x3ca: 0x0003, 0x3cb: 0x0003, + 0x3cc: 0x0003, 0x3cd: 0x0003, 0x3ce: 0x0003, 0x3cf: 0x0003, 0x3d1: 0x0003, + // Block 0x10, offset 0x400 + 0x403: 0x0001, 0x404: 0x0001, 0x405: 0x0001, + 0x406: 0x0001, 0x407: 0x0001, 0x408: 0x0001, 0x409: 0x0001, + // Block 0x11, offset 0x440 + 0x451: 0x0001, + 0x452: 0x0001, 0x453: 0x0001, 0x454: 0x0001, 0x455: 0x0001, 0x456: 0x0001, 0x457: 0x0001, + 0x458: 0x0001, 0x459: 0x0001, 0x45a: 0x0001, 0x45b: 0x0001, 0x45c: 0x0001, 0x45d: 0x0001, + 0x45e: 0x0001, 0x45f: 0x0001, 0x460: 0x0001, 0x461: 0x0001, 0x462: 0x0001, 0x463: 0x0001, + 0x464: 0x0001, 0x465: 0x0001, 0x466: 0x0001, 0x467: 0x0001, 0x468: 0x0001, 0x469: 0x0001, + 0x46a: 0x0001, 0x46b: 0x0001, 0x46c: 0x0001, 0x46d: 0x0001, 0x46e: 0x0001, 0x46f: 0x0001, + 0x470: 0x0001, 0x471: 0x0001, 0x472: 0x0001, 0x473: 0x0001, 0x474: 0x0001, 0x475: 0x0001, + 0x476: 0x0001, 0x477: 0x0001, 0x478: 0x0001, 0x479: 0x0001, 0x47a: 0x0001, 0x47b: 0x0001, + 0x47c: 0x0001, 0x47d: 0x0001, 0x47f: 0x0001, + // Block 0x12, offset 0x480 + 0x481: 0x0001, 0x482: 0x0001, 0x484: 0x0001, 0x485: 0x0001, + 0x487: 0x0001, + // Block 0x13, offset 0x4c0 + 0x4c0: 0x0001, 0x4c1: 0x0001, 0x4c2: 0x0001, 0x4c3: 0x0001, 0x4c4: 0x0001, 0x4c5: 0x0001, + 0x4d0: 0x0001, 0x4d1: 0x0001, + 0x4d2: 0x0001, 0x4d3: 0x0001, 0x4d4: 0x0001, 0x4d5: 0x0001, 0x4d6: 0x0001, 0x4d7: 0x0001, + 0x4d8: 0x0001, 0x4d9: 0x0001, 0x4da: 0x0001, 0x4dc: 0x0001, + // Block 0x14, offset 0x500 + 0x50b: 0x0001, + 0x50c: 0x0001, 0x50d: 0x0001, 0x50e: 0x0001, 0x50f: 0x0001, 0x510: 0x0001, 0x511: 0x0001, + 0x512: 0x0001, 0x513: 0x0001, 0x514: 0x0001, 0x515: 0x0001, 0x516: 0x0001, 0x517: 0x0001, + 0x518: 0x0001, 0x519: 0x0001, 0x51a: 0x0001, 0x51b: 0x0001, 0x51c: 0x0001, 0x51d: 0x0001, + 0x51e: 0x0001, 0x51f: 0x0001, + 0x530: 0x0001, + // Block 0x15, offset 0x540 + 0x556: 0x0001, 0x557: 0x0001, + 0x558: 0x0001, 0x559: 0x0001, 0x55a: 0x0001, 0x55b: 0x0001, 0x55c: 0x0001, 0x55d: 0x0001, + 0x55f: 0x0001, 0x560: 0x0001, 0x561: 0x0001, 0x562: 0x0001, 0x563: 0x0001, + 0x564: 0x0001, 0x567: 0x0001, 0x568: 0x0001, + 0x56a: 0x0001, 0x56b: 0x0001, 0x56c: 0x0001, 0x56d: 0x0001, + // Block 0x16, offset 0x580 + 0x58f: 0x0001, 0x591: 0x0001, + 0x5b0: 0x0001, 0x5b1: 0x0001, 0x5b2: 0x0001, 0x5b3: 0x0001, 0x5b4: 0x0001, 0x5b5: 0x0001, + 0x5b6: 0x0001, 0x5b7: 0x0001, 0x5b8: 0x0001, 0x5b9: 0x0001, 0x5ba: 0x0001, 0x5bb: 0x0001, + 0x5bc: 0x0001, 0x5bd: 0x0001, 0x5be: 0x0001, 0x5bf: 0x0001, + // Block 0x17, offset 0x5c0 + 0x5c0: 0x0001, 0x5c1: 0x0001, 0x5c2: 0x0001, 0x5c3: 0x0001, 0x5c4: 0x0001, 0x5c5: 0x0001, + 0x5c6: 0x0001, 0x5c7: 0x0001, 0x5c8: 0x0001, 0x5c9: 0x0001, 0x5ca: 0x0001, + // Block 0x18, offset 0x600 + 0x626: 0x0001, 0x627: 0x0001, 0x628: 0x0001, 0x629: 0x0001, + 0x62a: 0x0001, 0x62b: 0x0001, 0x62c: 0x0001, 0x62d: 0x0001, 0x62e: 0x0001, 0x62f: 0x0001, + 0x630: 0x0001, + // Block 0x19, offset 0x640 + 0x66b: 0x0001, 0x66c: 0x0001, 0x66d: 0x0001, 0x66e: 0x0001, 0x66f: 0x0001, + 0x670: 0x0001, 0x671: 0x0001, 0x672: 0x0001, 0x673: 0x0001, + 0x67d: 0x0001, + // Block 0x1a, offset 0x680 + 0x696: 0x0001, 0x697: 0x0001, + 0x698: 0x0001, 0x699: 0x0001, 0x69b: 0x0001, 0x69c: 0x0001, 0x69d: 0x0001, + 0x69e: 0x0001, 0x69f: 0x0001, 0x6a0: 0x0001, 0x6a1: 0x0001, 0x6a2: 0x0001, 0x6a3: 0x0001, + 0x6a5: 0x0001, 0x6a6: 0x0001, 0x6a7: 0x0001, 0x6a9: 0x0001, + 0x6aa: 0x0001, 0x6ab: 0x0001, 0x6ac: 0x0001, 0x6ad: 0x0001, + // Block 0x1b, offset 0x6c0 + 0x6d9: 0x0001, 0x6da: 0x0001, 0x6db: 0x0001, + // Block 0x1c, offset 0x700 + 0x710: 0x0001, 0x711: 0x0001, + 0x718: 0x0001, 0x719: 0x0001, 0x71a: 0x0001, 0x71b: 0x0001, 0x71c: 0x0001, 0x71d: 0x0001, + 0x71e: 0x0001, 0x71f: 0x0001, + // Block 0x1d, offset 0x740 + 0x74a: 0x0001, 0x74b: 0x0001, + 0x74c: 0x0001, 0x74d: 0x0001, 0x74e: 0x0001, 0x74f: 0x0001, 0x750: 0x0001, 0x751: 0x0001, + 0x752: 0x0001, 0x753: 0x0001, 0x754: 0x0001, 0x755: 0x0001, 0x756: 0x0001, 0x757: 0x0001, + 0x758: 0x0001, 0x759: 0x0001, 0x75a: 0x0001, 0x75b: 0x0001, 0x75c: 0x0001, 0x75d: 0x0001, + 0x75e: 0x0001, 0x75f: 0x0001, 0x760: 0x0001, 0x761: 0x0001, 0x762: 0x0001, 0x763: 0x0001, + 0x764: 0x0001, 0x765: 0x0001, 0x766: 0x0001, 0x767: 0x0001, 0x768: 0x0001, 0x769: 0x0001, + 0x76a: 0x0001, 0x76b: 0x0001, 0x76c: 0x0001, 0x76d: 0x0001, 0x76e: 0x0001, 0x76f: 0x0001, + 0x770: 0x0001, 0x771: 0x0001, 0x772: 0x0001, 0x773: 0x0001, 0x774: 0x0001, 0x775: 0x0001, + 0x776: 0x0001, 0x777: 0x0001, 0x778: 0x0001, 0x779: 0x0001, 0x77a: 0x0001, 0x77b: 0x0001, + 0x77c: 0x0001, 0x77d: 0x0001, 0x77e: 0x0001, 0x77f: 0x0001, + // Block 0x1e, offset 0x780 + 0x780: 0x0001, 0x781: 0x0001, 0x782: 0x0001, + 0x7ba: 0x0001, + 0x7bc: 0x0001, + // Block 0x1f, offset 0x7c0 + 0x7c1: 0x0001, 0x7c2: 0x0001, 0x7c3: 0x0001, 0x7c4: 0x0001, 0x7c5: 0x0001, + 0x7c6: 0x0001, 0x7c7: 0x0001, 0x7c8: 0x0001, + 0x7cd: 0x0001, 0x7d1: 0x0001, + 0x7d2: 0x0001, 0x7d3: 0x0001, 0x7d4: 0x0001, 0x7d5: 0x0001, 0x7d6: 0x0001, 0x7d7: 0x0001, + 0x7e2: 0x0001, 0x7e3: 0x0001, + // Block 0x20, offset 0x800 + 0x801: 0x0001, + 0x83c: 0x0001, + // Block 0x21, offset 0x840 + 0x841: 0x0001, 0x842: 0x0001, 0x843: 0x0001, 0x844: 0x0001, + 0x84d: 0x0001, + 0x862: 0x0001, 0x863: 0x0001, + 0x87e: 0x0001, + // Block 0x22, offset 0x880 + 0x881: 0x0001, 0x882: 0x0001, + 0x8bc: 0x0001, + // Block 0x23, offset 0x8c0 + 0x8c1: 0x0001, 0x8c2: 0x0001, + 0x8c7: 0x0001, 0x8c8: 0x0001, 0x8cb: 0x0001, + 0x8cc: 0x0001, 0x8cd: 0x0001, 0x8d1: 0x0001, + 0x8f0: 0x0001, 0x8f1: 0x0001, 0x8f5: 0x0001, + // Block 0x24, offset 0x900 + 0x901: 0x0001, 0x902: 0x0001, 0x903: 0x0001, 0x904: 0x0001, 0x905: 0x0001, + 0x907: 0x0001, 0x908: 0x0001, + 0x90d: 0x0001, + 0x922: 0x0001, 0x923: 0x0001, + 0x93a: 0x0001, 0x93b: 0x0001, + 0x93c: 0x0001, 0x93d: 0x0001, 0x93e: 0x0001, 0x93f: 0x0001, + // Block 0x25, offset 0x940 + 0x941: 0x0001, + 0x97c: 0x0001, 0x97f: 0x0001, + // Block 0x26, offset 0x980 + 0x981: 0x0001, 0x982: 0x0001, 0x983: 0x0001, 0x984: 0x0001, + 0x98d: 0x0001, + 0x995: 0x0001, 0x996: 0x0001, + 0x9a2: 0x0001, 0x9a3: 0x0001, + // Block 0x27, offset 0x9c0 + 0x9c2: 0x0001, + // Block 0x28, offset 0xa00 + 0xa00: 0x0001, + 0xa0d: 0x0001, + // Block 0x29, offset 0xa40 + 0xa40: 0x0001, 0xa44: 0x0001, + 0xa7c: 0x0001, 0xa7e: 0x0001, 0xa7f: 0x0001, + // Block 0x2a, offset 0xa80 + 0xa80: 0x0001, + 0xa86: 0x0001, 0xa87: 0x0001, 0xa88: 0x0001, 0xa8a: 0x0001, 0xa8b: 0x0001, + 0xa8c: 0x0001, 0xa8d: 0x0001, + 0xa95: 0x0001, 0xa96: 0x0001, + 0xaa2: 0x0001, 0xaa3: 0x0001, + // Block 0x2b, offset 0xac0 + 0xac6: 0x0001, + 0xacc: 0x0001, 0xacd: 0x0001, + 0xae2: 0x0001, 0xae3: 0x0001, + // Block 0x2c, offset 0xb00 + 0xb00: 0x0001, 0xb01: 0x0001, + 0xb3b: 0x0001, + 0xb3c: 0x0001, + // Block 0x2d, offset 0xb40 + 0xb41: 0x0001, 0xb42: 0x0001, 0xb43: 0x0001, 0xb44: 0x0001, + 0xb4d: 0x0001, + 0xb62: 0x0001, 0xb63: 0x0001, + // Block 0x2e, offset 0xb80 + 0xb81: 0x0001, + // Block 0x2f, offset 0xbc0 + 0xbca: 0x0001, + 0xbd2: 0x0001, 0xbd3: 0x0001, 0xbd4: 0x0001, 0xbd6: 0x0001, + // Block 0x30, offset 0xc00 + 0xc31: 0x0001, 0xc34: 0x0001, 0xc35: 0x0001, + 0xc36: 0x0001, 0xc37: 0x0001, 0xc38: 0x0001, 0xc39: 0x0001, 0xc3a: 0x0001, + // Block 0x31, offset 0xc40 + 0xc47: 0x0001, 0xc48: 0x0001, 0xc49: 0x0001, 0xc4a: 0x0001, 0xc4b: 0x0001, + 0xc4c: 0x0001, 0xc4d: 0x0001, 0xc4e: 0x0001, + // Block 0x32, offset 0xc80 + 0xcb1: 0x0001, 0xcb4: 0x0001, 0xcb5: 0x0001, + 0xcb6: 0x0001, 0xcb7: 0x0001, 0xcb8: 0x0001, 0xcb9: 0x0001, 0xcba: 0x0001, 0xcbb: 0x0001, + 0xcbc: 0x0001, + // Block 0x33, offset 0xcc0 + 0xcc8: 0x0001, 0xcc9: 0x0001, 0xcca: 0x0001, 0xccb: 0x0001, + 0xccc: 0x0001, 0xccd: 0x0001, 0xcce: 0x0001, + // Block 0x34, offset 0xd00 + 0xd18: 0x0001, 0xd19: 0x0001, + 0xd35: 0x0001, + 0xd37: 0x0001, 0xd39: 0x0001, + // Block 0x35, offset 0xd40 + 0xd71: 0x0001, 0xd72: 0x0001, 0xd73: 0x0001, 0xd74: 0x0001, 0xd75: 0x0001, + 0xd76: 0x0001, 0xd77: 0x0001, 0xd78: 0x0001, 0xd79: 0x0001, 0xd7a: 0x0001, 0xd7b: 0x0001, + 0xd7c: 0x0001, 0xd7d: 0x0001, 0xd7e: 0x0001, + // Block 0x36, offset 0xd80 + 0xd80: 0x0001, 0xd81: 0x0001, 0xd82: 0x0001, 0xd83: 0x0001, 0xd84: 0x0001, + 0xd86: 0x0001, 0xd87: 0x0001, + 0xd8d: 0x0001, 0xd8e: 0x0001, 0xd8f: 0x0001, 0xd90: 0x0001, 0xd91: 0x0001, + 0xd92: 0x0001, 0xd93: 0x0001, 0xd94: 0x0001, 0xd95: 0x0001, 0xd96: 0x0001, 0xd97: 0x0001, + 0xd99: 0x0001, 0xd9a: 0x0001, 0xd9b: 0x0001, 0xd9c: 0x0001, 0xd9d: 0x0001, + 0xd9e: 0x0001, 0xd9f: 0x0001, 0xda0: 0x0001, 0xda1: 0x0001, 0xda2: 0x0001, 0xda3: 0x0001, + 0xda4: 0x0001, 0xda5: 0x0001, 0xda6: 0x0001, 0xda7: 0x0001, 0xda8: 0x0001, 0xda9: 0x0001, + 0xdaa: 0x0001, 0xdab: 0x0001, 0xdac: 0x0001, 0xdad: 0x0001, 0xdae: 0x0001, 0xdaf: 0x0001, + 0xdb0: 0x0001, 0xdb1: 0x0001, 0xdb2: 0x0001, 0xdb3: 0x0001, 0xdb4: 0x0001, 0xdb5: 0x0001, + 0xdb6: 0x0001, 0xdb7: 0x0001, 0xdb8: 0x0001, 0xdb9: 0x0001, 0xdba: 0x0001, 0xdbb: 0x0001, + 0xdbc: 0x0001, + // Block 0x37, offset 0xdc0 + 0xdc6: 0x0001, + // Block 0x38, offset 0xe00 + 0xe2d: 0x0001, 0xe2e: 0x0001, 0xe2f: 0x0001, + 0xe30: 0x0001, 0xe32: 0x0001, 0xe33: 0x0001, 0xe34: 0x0001, 0xe35: 0x0001, + 0xe36: 0x0001, 0xe37: 0x0001, 0xe39: 0x0001, 0xe3a: 0x0001, + 0xe3d: 0x0001, 0xe3e: 0x0001, + // Block 0x39, offset 0xe40 + 0xe58: 0x0001, 0xe59: 0x0001, + 0xe5e: 0x0001, 0xe5f: 0x0001, 0xe60: 0x0001, + 0xe71: 0x0001, 0xe72: 0x0001, 0xe73: 0x0001, 0xe74: 0x0001, + // Block 0x3a, offset 0xe80 + 0xe82: 0x0001, 0xe85: 0x0001, + 0xe86: 0x0001, + 0xe8d: 0x0001, + 0xe9d: 0x0001, + // Block 0x3b, offset 0xec0 + 0xec0: 0x0002, 0xec1: 0x0002, 0xec2: 0x0002, 0xec3: 0x0002, 0xec4: 0x0002, 0xec5: 0x0002, + 0xec6: 0x0002, 0xec7: 0x0002, 0xec8: 0x0002, 0xec9: 0x0002, 0xeca: 0x0002, 0xecb: 0x0002, + 0xecc: 0x0002, 0xecd: 0x0002, 0xece: 0x0002, 0xecf: 0x0002, 0xed0: 0x0002, 0xed1: 0x0002, + 0xed2: 0x0002, 0xed3: 0x0002, 0xed4: 0x0002, 0xed5: 0x0002, 0xed6: 0x0002, 0xed7: 0x0002, + 0xed8: 0x0002, 0xed9: 0x0002, 0xeda: 0x0002, 0xedb: 0x0002, 0xedc: 0x0002, 0xedd: 0x0002, + 0xede: 0x0002, 0xedf: 0x0002, 0xee0: 0x0002, 0xee1: 0x0002, 0xee2: 0x0002, 0xee3: 0x0002, + 0xee4: 0x0002, 0xee5: 0x0002, 0xee6: 0x0002, 0xee7: 0x0002, 0xee8: 0x0002, 0xee9: 0x0002, + 0xeea: 0x0002, 0xeeb: 0x0002, 0xeec: 0x0002, 0xeed: 0x0002, 0xeee: 0x0002, 0xeef: 0x0002, + 0xef0: 0x0002, 0xef1: 0x0002, 0xef2: 0x0002, 0xef3: 0x0002, 0xef4: 0x0002, 0xef5: 0x0002, + 0xef6: 0x0002, 0xef7: 0x0002, 0xef8: 0x0002, 0xef9: 0x0002, 0xefa: 0x0002, 0xefb: 0x0002, + 0xefc: 0x0002, 0xefd: 0x0002, 0xefe: 0x0002, 0xeff: 0x0002, + // Block 0x3c, offset 0xf00 + 0xf00: 0x0002, 0xf01: 0x0002, 0xf02: 0x0002, 0xf03: 0x0002, 0xf04: 0x0002, 0xf05: 0x0002, + 0xf06: 0x0002, 0xf07: 0x0002, 0xf08: 0x0002, 0xf09: 0x0002, 0xf0a: 0x0002, 0xf0b: 0x0002, + 0xf0c: 0x0002, 0xf0d: 0x0002, 0xf0e: 0x0002, 0xf0f: 0x0002, 0xf10: 0x0002, 0xf11: 0x0002, + 0xf12: 0x0002, 0xf13: 0x0002, 0xf14: 0x0002, 0xf15: 0x0002, 0xf16: 0x0002, 0xf17: 0x0002, + 0xf18: 0x0002, 0xf19: 0x0002, 0xf1a: 0x0002, 0xf1b: 0x0002, 0xf1c: 0x0002, 0xf1d: 0x0002, + 0xf1e: 0x0002, 0xf1f: 0x0002, + // Block 0x3d, offset 0xf40 + 0xf5d: 0x0001, + 0xf5e: 0x0001, 0xf5f: 0x0001, + // Block 0x3e, offset 0xf80 + 0xf92: 0x0001, 0xf93: 0x0001, 0xf94: 0x0001, + 0xfb2: 0x0001, 0xfb3: 0x0001, + // Block 0x3f, offset 0xfc0 + 0xfd2: 0x0001, 0xfd3: 0x0001, + 0xff2: 0x0001, 0xff3: 0x0001, + // Block 0x40, offset 0x1000 + 0x1034: 0x0001, 0x1035: 0x0001, + 0x1037: 0x0001, 0x1038: 0x0001, 0x1039: 0x0001, 0x103a: 0x0001, 0x103b: 0x0001, + 0x103c: 0x0001, 0x103d: 0x0001, + // Block 0x41, offset 0x1040 + 0x1046: 0x0001, 0x1049: 0x0001, 0x104a: 0x0001, 0x104b: 0x0001, + 0x104c: 0x0001, 0x104d: 0x0001, 0x104e: 0x0001, 0x104f: 0x0001, 0x1050: 0x0001, 0x1051: 0x0001, + 0x1052: 0x0001, 0x1053: 0x0001, + 0x105d: 0x0001, + // Block 0x42, offset 0x1080 + 0x108b: 0x0001, + 0x108c: 0x0001, 0x108d: 0x0001, 0x108e: 0x0001, 0x108f: 0x0001, + // Block 0x43, offset 0x10c0 + 0x10c5: 0x0001, + 0x10c6: 0x0001, + 0x10e9: 0x0001, + // Block 0x44, offset 0x1100 + 0x1120: 0x0001, 0x1121: 0x0001, 0x1122: 0x0001, + 0x1127: 0x0001, 0x1128: 0x0001, + 0x1132: 0x0001, + 0x1139: 0x0001, 0x113a: 0x0001, 0x113b: 0x0001, + // Block 0x45, offset 0x1140 + 0x1157: 0x0001, + 0x1158: 0x0001, 0x115b: 0x0001, + // Block 0x46, offset 0x1180 + 0x1196: 0x0001, + 0x1198: 0x0001, 0x1199: 0x0001, 0x119a: 0x0001, 0x119b: 0x0001, 0x119c: 0x0001, 0x119d: 0x0001, + 0x119e: 0x0001, 0x11a0: 0x0001, 0x11a2: 0x0001, + 0x11a5: 0x0001, 0x11a6: 0x0001, 0x11a7: 0x0001, 0x11a8: 0x0001, 0x11a9: 0x0001, + 0x11aa: 0x0001, 0x11ab: 0x0001, 0x11ac: 0x0001, + 0x11b3: 0x0001, 0x11b4: 0x0001, 0x11b5: 0x0001, + 0x11b6: 0x0001, 0x11b7: 0x0001, 0x11b8: 0x0001, 0x11b9: 0x0001, 0x11ba: 0x0001, 0x11bb: 0x0001, + 0x11bc: 0x0001, 0x11bf: 0x0001, + // Block 0x47, offset 0x11c0 + 0x11f0: 0x0001, 0x11f1: 0x0001, 0x11f2: 0x0001, 0x11f3: 0x0001, 0x11f4: 0x0001, 0x11f5: 0x0001, + 0x11f6: 0x0001, 0x11f7: 0x0001, 0x11f8: 0x0001, 0x11f9: 0x0001, 0x11fa: 0x0001, 0x11fb: 0x0001, + 0x11fc: 0x0001, 0x11fd: 0x0001, 0x11fe: 0x0001, 0x11ff: 0x0001, + // Block 0x48, offset 0x1200 + 0x1200: 0x0001, 0x1201: 0x0001, 0x1202: 0x0001, 0x1203: 0x0001, 0x1204: 0x0001, 0x1205: 0x0001, + 0x1206: 0x0001, 0x1207: 0x0001, 0x1208: 0x0001, 0x1209: 0x0001, 0x120a: 0x0001, 0x120b: 0x0001, + 0x120c: 0x0001, 0x120d: 0x0001, 0x120e: 0x0001, + // Block 0x49, offset 0x1240 + 0x1240: 0x0001, 0x1241: 0x0001, 0x1242: 0x0001, 0x1243: 0x0001, + 0x1274: 0x0001, + 0x1276: 0x0001, 0x1277: 0x0001, 0x1278: 0x0001, 0x1279: 0x0001, 0x127a: 0x0001, + 0x127c: 0x0001, + // Block 0x4a, offset 0x1280 + 0x1282: 0x0001, + 0x12ab: 0x0001, 0x12ac: 0x0001, 0x12ad: 0x0001, 0x12ae: 0x0001, 0x12af: 0x0001, + 0x12b0: 0x0001, 0x12b1: 0x0001, 0x12b2: 0x0001, 0x12b3: 0x0001, + // Block 0x4b, offset 0x12c0 + 0x12c0: 0x0001, 0x12c1: 0x0001, + 0x12e2: 0x0001, 0x12e3: 0x0001, + 0x12e4: 0x0001, 0x12e5: 0x0001, 0x12e8: 0x0001, 0x12e9: 0x0001, + 0x12eb: 0x0001, 0x12ec: 0x0001, 0x12ed: 0x0001, + // Block 0x4c, offset 0x1300 + 0x1326: 0x0001, 0x1328: 0x0001, 0x1329: 0x0001, + 0x132d: 0x0001, 0x132f: 0x0001, + 0x1330: 0x0001, 0x1331: 0x0001, + // Block 0x4d, offset 0x1340 + 0x136c: 0x0001, 0x136d: 0x0001, 0x136e: 0x0001, 0x136f: 0x0001, + 0x1370: 0x0001, 0x1371: 0x0001, 0x1372: 0x0001, 0x1373: 0x0001, + 0x1376: 0x0001, 0x1377: 0x0001, + // Block 0x4e, offset 0x1380 + 0x1390: 0x0001, 0x1391: 0x0001, + 0x1392: 0x0001, 0x1394: 0x0001, 0x1395: 0x0001, 0x1396: 0x0001, 0x1397: 0x0001, + 0x1398: 0x0001, 0x1399: 0x0001, 0x139a: 0x0001, 0x139b: 0x0001, 0x139c: 0x0001, 0x139d: 0x0001, + 0x139e: 0x0001, 0x139f: 0x0001, 0x13a0: 0x0001, 0x13a2: 0x0001, 0x13a3: 0x0001, + 0x13a4: 0x0001, 0x13a5: 0x0001, 0x13a6: 0x0001, 0x13a7: 0x0001, 0x13a8: 0x0001, + 0x13ad: 0x0001, + 0x13b4: 0x0001, + 0x13b8: 0x0001, 0x13b9: 0x0001, + // Block 0x4f, offset 0x13c0 + 0x13cb: 0x0001, + 0x13cc: 0x0001, 0x13cd: 0x0001, 0x13ce: 0x0001, 0x13cf: 0x0001, 0x13d0: 0x0003, + 0x13d3: 0x0003, 0x13d4: 0x0003, 0x13d5: 0x0003, 0x13d6: 0x0003, + 0x13d8: 0x0003, 0x13d9: 0x0003, 0x13dc: 0x0003, 0x13dd: 0x0003, + 0x13e0: 0x0003, 0x13e1: 0x0003, 0x13e2: 0x0003, + 0x13e4: 0x0003, 0x13e5: 0x0003, 0x13e6: 0x0003, 0x13e7: 0x0003, 0x13e8: 0x0001, 0x13e9: 0x0001, + 0x13ea: 0x0001, 0x13eb: 0x0001, 0x13ec: 0x0001, 0x13ed: 0x0001, 0x13ee: 0x0001, + 0x13f0: 0x0003, 0x13f2: 0x0003, 0x13f3: 0x0003, 0x13f5: 0x0003, + 0x13fb: 0x0003, + 0x13fe: 0x0003, + // Block 0x50, offset 0x1400 + 0x1420: 0x0001, 0x1421: 0x0001, 0x1422: 0x0001, 0x1423: 0x0001, + 0x1424: 0x0001, 0x1426: 0x0001, 0x1427: 0x0001, 0x1428: 0x0001, 0x1429: 0x0001, + 0x142a: 0x0001, 0x142b: 0x0001, 0x142c: 0x0001, 0x142d: 0x0001, 0x142e: 0x0001, 0x142f: 0x0001, + 0x1434: 0x0003, + 0x143f: 0x0003, + // Block 0x51, offset 0x1440 + 0x1441: 0x0003, 0x1442: 0x0003, 0x1443: 0x0003, 0x1444: 0x0003, + 0x146c: 0x0003, + // Block 0x52, offset 0x1480 + 0x1490: 0x0001, 0x1491: 0x0001, + 0x1492: 0x0001, 0x1493: 0x0001, 0x1494: 0x0001, 0x1495: 0x0001, 0x1496: 0x0001, 0x1497: 0x0001, + 0x1498: 0x0001, 0x1499: 0x0001, 0x149a: 0x0001, 0x149b: 0x0001, 0x149c: 0x0001, 0x149d: 0x0001, + 0x149e: 0x0001, 0x149f: 0x0001, 0x14a0: 0x0001, 0x14a1: 0x0001, 0x14a2: 0x0001, 0x14a3: 0x0001, + 0x14a4: 0x0001, 0x14a5: 0x0001, 0x14a6: 0x0001, 0x14a7: 0x0001, 0x14a8: 0x0001, 0x14a9: 0x0001, + 0x14aa: 0x0001, 0x14ab: 0x0001, 0x14ac: 0x0001, 0x14ad: 0x0001, 0x14ae: 0x0001, 0x14af: 0x0001, + 0x14b0: 0x0001, + // Block 0x53, offset 0x14c0 + 0x14c3: 0x0003, 0x14c5: 0x0003, + 0x14c9: 0x0003, + 0x14d3: 0x0003, 0x14d6: 0x0003, + 0x14e1: 0x0003, 0x14e2: 0x0003, + 0x14e6: 0x0003, + 0x14eb: 0x0003, + // Block 0x54, offset 0x1500 + 0x1513: 0x0003, 0x1514: 0x0003, + 0x151b: 0x0003, 0x151c: 0x0003, 0x151d: 0x0003, + 0x151e: 0x0003, 0x1520: 0x0003, 0x1521: 0x0003, 0x1522: 0x0003, 0x1523: 0x0003, + 0x1524: 0x0003, 0x1525: 0x0003, 0x1526: 0x0003, 0x1527: 0x0003, 0x1528: 0x0003, 0x1529: 0x0003, + 0x152a: 0x0003, 0x152b: 0x0003, + 0x1530: 0x0003, 0x1531: 0x0003, 0x1532: 0x0003, 0x1533: 0x0003, 0x1534: 0x0003, 0x1535: 0x0003, + 0x1536: 0x0003, 0x1537: 0x0003, 0x1538: 0x0003, 0x1539: 0x0003, + // Block 0x55, offset 0x1540 + 0x1549: 0x0003, + 0x1550: 0x0003, 0x1551: 0x0003, + 0x1552: 0x0003, 0x1553: 0x0003, 0x1554: 0x0003, 0x1555: 0x0003, 0x1556: 0x0003, 0x1557: 0x0003, + 0x1558: 0x0003, 0x1559: 0x0003, + 0x1578: 0x0003, 0x1579: 0x0003, + // Block 0x56, offset 0x1580 + 0x1592: 0x0003, 0x1594: 0x0003, + 0x15a7: 0x0003, + // Block 0x57, offset 0x15c0 + 0x15c0: 0x0003, 0x15c2: 0x0003, 0x15c3: 0x0003, + 0x15c7: 0x0003, 0x15c8: 0x0003, 0x15cb: 0x0003, + 0x15cf: 0x0003, 0x15d1: 0x0003, + 0x15d5: 0x0003, + 0x15da: 0x0003, 0x15dd: 0x0003, + 0x15de: 0x0003, 0x15df: 0x0003, 0x15e0: 0x0003, 0x15e3: 0x0003, + 0x15e5: 0x0003, 0x15e7: 0x0003, 0x15e8: 0x0003, 0x15e9: 0x0003, + 0x15ea: 0x0003, 0x15eb: 0x0003, 0x15ec: 0x0003, 0x15ee: 0x0003, + 0x15f4: 0x0003, 0x15f5: 0x0003, + 0x15f6: 0x0003, 0x15f7: 0x0003, + 0x15fc: 0x0003, 0x15fd: 0x0003, + // Block 0x58, offset 0x1600 + 0x1608: 0x0003, + 0x160c: 0x0003, + 0x1612: 0x0003, + 0x1620: 0x0003, 0x1621: 0x0003, + 0x1624: 0x0003, 0x1625: 0x0003, 0x1626: 0x0003, 0x1627: 0x0003, + 0x162a: 0x0003, 0x162b: 0x0003, 0x162e: 0x0003, 0x162f: 0x0003, + // Block 0x59, offset 0x1640 + 0x1642: 0x0003, 0x1643: 0x0003, + 0x1646: 0x0003, 0x1647: 0x0003, + 0x1655: 0x0003, + 0x1659: 0x0003, + 0x1665: 0x0003, + 0x167f: 0x0003, + // Block 0x5a, offset 0x1680 + 0x1692: 0x0003, + 0x169a: 0x0002, 0x169b: 0x0002, + 0x16a9: 0x0002, + 0x16aa: 0x0002, + // Block 0x5b, offset 0x16c0 + 0x16e9: 0x0002, + 0x16ea: 0x0002, 0x16eb: 0x0002, 0x16ec: 0x0002, + 0x16f0: 0x0002, 0x16f3: 0x0002, + // Block 0x5c, offset 0x1700 + 0x1720: 0x0003, 0x1721: 0x0003, 0x1722: 0x0003, 0x1723: 0x0003, + 0x1724: 0x0003, 0x1725: 0x0003, 0x1726: 0x0003, 0x1727: 0x0003, 0x1728: 0x0003, 0x1729: 0x0003, + 0x172a: 0x0003, 0x172b: 0x0003, 0x172c: 0x0003, 0x172d: 0x0003, 0x172e: 0x0003, 0x172f: 0x0003, + 0x1730: 0x0003, 0x1731: 0x0003, 0x1732: 0x0003, 0x1733: 0x0003, 0x1734: 0x0003, 0x1735: 0x0003, + 0x1736: 0x0003, 0x1737: 0x0003, 0x1738: 0x0003, 0x1739: 0x0003, 0x173a: 0x0003, 0x173b: 0x0003, + 0x173c: 0x0003, 0x173d: 0x0003, 0x173e: 0x0003, 0x173f: 0x0003, + // Block 0x5d, offset 0x1740 + 0x1740: 0x0003, 0x1741: 0x0003, 0x1742: 0x0003, 0x1743: 0x0003, 0x1744: 0x0003, 0x1745: 0x0003, + 0x1746: 0x0003, 0x1747: 0x0003, 0x1748: 0x0003, 0x1749: 0x0003, 0x174a: 0x0003, 0x174b: 0x0003, + 0x174c: 0x0003, 0x174d: 0x0003, 0x174e: 0x0003, 0x174f: 0x0003, 0x1750: 0x0003, 0x1751: 0x0003, + 0x1752: 0x0003, 0x1753: 0x0003, 0x1754: 0x0003, 0x1755: 0x0003, 0x1756: 0x0003, 0x1757: 0x0003, + 0x1758: 0x0003, 0x1759: 0x0003, 0x175a: 0x0003, 0x175b: 0x0003, 0x175c: 0x0003, 0x175d: 0x0003, + 0x175e: 0x0003, 0x175f: 0x0003, 0x1760: 0x0003, 0x1761: 0x0003, 0x1762: 0x0003, 0x1763: 0x0003, + 0x1764: 0x0003, 0x1765: 0x0003, 0x1766: 0x0003, 0x1767: 0x0003, 0x1768: 0x0003, 0x1769: 0x0003, + 0x176a: 0x0003, 0x176b: 0x0003, 0x176c: 0x0003, 0x176d: 0x0003, 0x176e: 0x0003, 0x176f: 0x0003, + 0x1770: 0x0003, 0x1771: 0x0003, 0x1772: 0x0003, 0x1773: 0x0003, 0x1774: 0x0003, 0x1775: 0x0003, + 0x1776: 0x0003, 0x1777: 0x0003, 0x1778: 0x0003, 0x1779: 0x0003, 0x177a: 0x0003, 0x177b: 0x0003, + 0x177c: 0x0003, 0x177d: 0x0003, 0x177e: 0x0003, 0x177f: 0x0003, + // Block 0x5e, offset 0x1780 + 0x1780: 0x0003, 0x1781: 0x0003, 0x1782: 0x0003, 0x1783: 0x0003, 0x1784: 0x0003, 0x1785: 0x0003, + 0x1786: 0x0003, 0x1787: 0x0003, 0x1788: 0x0003, 0x1789: 0x0003, 0x178a: 0x0003, 0x178b: 0x0003, + 0x178c: 0x0003, 0x178d: 0x0003, 0x178e: 0x0003, 0x178f: 0x0003, 0x1790: 0x0003, 0x1791: 0x0003, + 0x1792: 0x0003, 0x1793: 0x0003, 0x1794: 0x0003, 0x1795: 0x0003, 0x1796: 0x0003, 0x1797: 0x0003, + 0x1798: 0x0003, 0x1799: 0x0003, 0x179a: 0x0003, 0x179b: 0x0003, 0x179c: 0x0003, 0x179d: 0x0003, + 0x179e: 0x0003, 0x179f: 0x0003, 0x17a0: 0x0003, 0x17a1: 0x0003, 0x17a2: 0x0003, 0x17a3: 0x0003, + 0x17a4: 0x0003, 0x17a5: 0x0003, 0x17a6: 0x0003, 0x17a7: 0x0003, 0x17a8: 0x0003, 0x17a9: 0x0003, + 0x17ab: 0x0003, 0x17ac: 0x0003, 0x17ad: 0x0003, 0x17ae: 0x0003, 0x17af: 0x0003, + 0x17b0: 0x0003, 0x17b1: 0x0003, 0x17b2: 0x0003, 0x17b3: 0x0003, 0x17b4: 0x0003, 0x17b5: 0x0003, + 0x17b6: 0x0003, 0x17b7: 0x0003, 0x17b8: 0x0003, 0x17b9: 0x0003, 0x17ba: 0x0003, 0x17bb: 0x0003, + 0x17bc: 0x0003, 0x17bd: 0x0003, 0x17be: 0x0003, 0x17bf: 0x0003, + // Block 0x5f, offset 0x17c0 + 0x17c0: 0x0003, 0x17c1: 0x0003, 0x17c2: 0x0003, 0x17c3: 0x0003, 0x17c4: 0x0003, 0x17c5: 0x0003, + 0x17c6: 0x0003, 0x17c7: 0x0003, 0x17c8: 0x0003, 0x17c9: 0x0003, 0x17ca: 0x0003, 0x17cb: 0x0003, + 0x17d0: 0x0003, 0x17d1: 0x0003, + 0x17d2: 0x0003, 0x17d3: 0x0003, 0x17d4: 0x0003, 0x17d5: 0x0003, 0x17d6: 0x0003, 0x17d7: 0x0003, + 0x17d8: 0x0003, 0x17d9: 0x0003, 0x17da: 0x0003, 0x17db: 0x0003, 0x17dc: 0x0003, 0x17dd: 0x0003, + 0x17de: 0x0003, 0x17df: 0x0003, 0x17e0: 0x0003, 0x17e1: 0x0003, 0x17e2: 0x0003, 0x17e3: 0x0003, + 0x17e4: 0x0003, 0x17e5: 0x0003, 0x17e6: 0x0003, 0x17e7: 0x0003, 0x17e8: 0x0003, 0x17e9: 0x0003, + 0x17ea: 0x0003, 0x17eb: 0x0003, 0x17ec: 0x0003, 0x17ed: 0x0003, 0x17ee: 0x0003, 0x17ef: 0x0003, + 0x17f0: 0x0003, 0x17f1: 0x0003, 0x17f2: 0x0003, 0x17f3: 0x0003, + // Block 0x60, offset 0x1800 + 0x1800: 0x0003, 0x1801: 0x0003, 0x1802: 0x0003, 0x1803: 0x0003, 0x1804: 0x0003, 0x1805: 0x0003, + 0x1806: 0x0003, 0x1807: 0x0003, 0x1808: 0x0003, 0x1809: 0x0003, 0x180a: 0x0003, 0x180b: 0x0003, + 0x180c: 0x0003, 0x180d: 0x0003, 0x180e: 0x0003, 0x180f: 0x0003, + 0x1812: 0x0003, 0x1813: 0x0003, 0x1814: 0x0003, 0x1815: 0x0003, + 0x1820: 0x0003, 0x1821: 0x0003, 0x1823: 0x0003, + 0x1824: 0x0003, 0x1825: 0x0003, 0x1826: 0x0003, 0x1827: 0x0003, 0x1828: 0x0003, 0x1829: 0x0003, + 0x1832: 0x0003, 0x1833: 0x0003, + 0x1836: 0x0003, 0x1837: 0x0003, + 0x183c: 0x0003, 0x183d: 0x0003, + // Block 0x61, offset 0x1840 + 0x1840: 0x0003, 0x1841: 0x0003, + 0x1846: 0x0003, 0x1847: 0x0003, 0x1848: 0x0003, 0x184b: 0x0003, + 0x184e: 0x0003, 0x184f: 0x0003, 0x1850: 0x0003, 0x1851: 0x0003, + 0x1862: 0x0003, 0x1863: 0x0003, + 0x1864: 0x0003, 0x1865: 0x0003, + 0x186f: 0x0003, + 0x187d: 0x0002, 0x187e: 0x0002, + // Block 0x62, offset 0x1880 + 0x1885: 0x0003, + 0x1886: 0x0003, 0x1889: 0x0003, + 0x188e: 0x0003, 0x188f: 0x0003, + 0x1894: 0x0002, 0x1895: 0x0002, + 0x189c: 0x0003, + 0x189e: 0x0003, + 0x18b0: 0x0002, 0x18b1: 0x0002, 0x18b2: 0x0002, 0x18b3: 0x0002, 0x18b4: 0x0002, 0x18b5: 0x0002, + 0x18b6: 0x0002, 0x18b7: 0x0002, + // Block 0x63, offset 0x18c0 + 0x18c0: 0x0003, 0x18c2: 0x0003, + 0x18c8: 0x0002, 0x18c9: 0x0002, 0x18ca: 0x0002, 0x18cb: 0x0002, + 0x18cc: 0x0002, 0x18cd: 0x0002, 0x18ce: 0x0002, 0x18cf: 0x0002, 0x18d0: 0x0002, 0x18d1: 0x0002, + 0x18d2: 0x0002, 0x18d3: 0x0002, + 0x18e0: 0x0003, 0x18e1: 0x0003, 0x18e3: 0x0003, + 0x18e4: 0x0003, 0x18e5: 0x0003, 0x18e7: 0x0003, 0x18e8: 0x0003, 0x18e9: 0x0003, + 0x18ea: 0x0003, 0x18ec: 0x0003, 0x18ed: 0x0003, 0x18ef: 0x0003, + 0x18ff: 0x0002, + // Block 0x64, offset 0x1900 + 0x190a: 0x0002, 0x190b: 0x0002, + 0x190c: 0x0002, 0x190d: 0x0002, 0x190e: 0x0002, 0x190f: 0x0002, + 0x1913: 0x0002, + 0x191e: 0x0003, 0x191f: 0x0003, 0x1921: 0x0002, + 0x192a: 0x0002, 0x192b: 0x0002, + 0x193d: 0x0002, 0x193e: 0x0002, 0x193f: 0x0003, + // Block 0x65, offset 0x1940 + 0x1944: 0x0002, 0x1945: 0x0002, + 0x1946: 0x0003, 0x1947: 0x0003, 0x1948: 0x0003, 0x1949: 0x0003, 0x194a: 0x0003, 0x194b: 0x0003, + 0x194c: 0x0003, 0x194d: 0x0003, 0x194e: 0x0002, 0x194f: 0x0003, 0x1950: 0x0003, 0x1951: 0x0003, + 0x1952: 0x0003, 0x1953: 0x0003, 0x1954: 0x0002, 0x1955: 0x0003, 0x1956: 0x0003, 0x1957: 0x0003, + 0x1958: 0x0003, 0x1959: 0x0003, 0x195a: 0x0003, 0x195b: 0x0003, 0x195c: 0x0003, 0x195d: 0x0003, + 0x195e: 0x0003, 0x195f: 0x0003, 0x1960: 0x0003, 0x1961: 0x0003, 0x1963: 0x0003, + 0x1968: 0x0003, 0x1969: 0x0003, + 0x196a: 0x0002, 0x196b: 0x0003, 0x196c: 0x0003, 0x196d: 0x0003, 0x196e: 0x0003, 0x196f: 0x0003, + 0x1970: 0x0003, 0x1971: 0x0003, 0x1972: 0x0002, 0x1973: 0x0002, 0x1974: 0x0003, 0x1975: 0x0002, + 0x1976: 0x0003, 0x1977: 0x0003, 0x1978: 0x0003, 0x1979: 0x0003, 0x197a: 0x0002, 0x197b: 0x0003, + 0x197c: 0x0003, 0x197d: 0x0002, 0x197e: 0x0003, 0x197f: 0x0003, + // Block 0x66, offset 0x1980 + 0x1985: 0x0002, + 0x198a: 0x0002, 0x198b: 0x0002, + 0x19a8: 0x0002, + 0x19bd: 0x0003, + // Block 0x67, offset 0x19c0 + 0x19cc: 0x0002, 0x19ce: 0x0002, + 0x19d3: 0x0002, 0x19d4: 0x0002, 0x19d5: 0x0002, 0x19d7: 0x0002, + 0x19f6: 0x0003, 0x19f7: 0x0003, 0x19f8: 0x0003, 0x19f9: 0x0003, 0x19fa: 0x0003, 0x19fb: 0x0003, + 0x19fc: 0x0003, 0x19fd: 0x0003, 0x19fe: 0x0003, 0x19ff: 0x0003, + // Block 0x68, offset 0x1a00 + 0x1a15: 0x0002, 0x1a16: 0x0002, 0x1a17: 0x0002, + 0x1a30: 0x0002, + 0x1a3f: 0x0002, + // Block 0x69, offset 0x1a40 + 0x1a5b: 0x0002, 0x1a5c: 0x0002, + // Block 0x6a, offset 0x1a80 + 0x1a90: 0x0002, + 0x1a95: 0x0002, 0x1a96: 0x0003, 0x1a97: 0x0003, + 0x1a98: 0x0003, 0x1a99: 0x0003, + // Block 0x6b, offset 0x1ac0 + 0x1aef: 0x0001, + 0x1af0: 0x0001, 0x1af1: 0x0001, + // Block 0x6c, offset 0x1b00 + 0x1b3f: 0x0001, + // Block 0x6d, offset 0x1b40 + 0x1b60: 0x0001, 0x1b61: 0x0001, 0x1b62: 0x0001, 0x1b63: 0x0001, + 0x1b64: 0x0001, 0x1b65: 0x0001, 0x1b66: 0x0001, 0x1b67: 0x0001, 0x1b68: 0x0001, 0x1b69: 0x0001, + 0x1b6a: 0x0001, 0x1b6b: 0x0001, 0x1b6c: 0x0001, 0x1b6d: 0x0001, 0x1b6e: 0x0001, 0x1b6f: 0x0001, + 0x1b70: 0x0001, 0x1b71: 0x0001, 0x1b72: 0x0001, 0x1b73: 0x0001, 0x1b74: 0x0001, 0x1b75: 0x0001, + 0x1b76: 0x0001, 0x1b77: 0x0001, 0x1b78: 0x0001, 0x1b79: 0x0001, 0x1b7a: 0x0001, 0x1b7b: 0x0001, + 0x1b7c: 0x0001, 0x1b7d: 0x0001, 0x1b7e: 0x0001, 0x1b7f: 0x0001, + // Block 0x6e, offset 0x1b80 + 0x1b80: 0x0002, 0x1b81: 0x0002, 0x1b82: 0x0002, 0x1b83: 0x0002, 0x1b84: 0x0002, 0x1b85: 0x0002, + 0x1b86: 0x0002, 0x1b87: 0x0002, 0x1b88: 0x0002, 0x1b89: 0x0002, 0x1b8a: 0x0002, 0x1b8b: 0x0002, + 0x1b8c: 0x0002, 0x1b8d: 0x0002, 0x1b8e: 0x0002, 0x1b8f: 0x0002, 0x1b90: 0x0002, 0x1b91: 0x0002, + 0x1b92: 0x0002, 0x1b93: 0x0002, 0x1b94: 0x0002, 0x1b95: 0x0002, 0x1b96: 0x0002, 0x1b97: 0x0002, + 0x1b98: 0x0002, 0x1b99: 0x0002, 0x1b9b: 0x0002, 0x1b9c: 0x0002, 0x1b9d: 0x0002, + 0x1b9e: 0x0002, 0x1b9f: 0x0002, 0x1ba0: 0x0002, 0x1ba1: 0x0002, 0x1ba2: 0x0002, 0x1ba3: 0x0002, + 0x1ba4: 0x0002, 0x1ba5: 0x0002, 0x1ba6: 0x0002, 0x1ba7: 0x0002, 0x1ba8: 0x0002, 0x1ba9: 0x0002, + 0x1baa: 0x0002, 0x1bab: 0x0002, 0x1bac: 0x0002, 0x1bad: 0x0002, 0x1bae: 0x0002, 0x1baf: 0x0002, + 0x1bb0: 0x0002, 0x1bb1: 0x0002, 0x1bb2: 0x0002, 0x1bb3: 0x0002, 0x1bb4: 0x0002, 0x1bb5: 0x0002, + 0x1bb6: 0x0002, 0x1bb7: 0x0002, 0x1bb8: 0x0002, 0x1bb9: 0x0002, 0x1bba: 0x0002, 0x1bbb: 0x0002, + 0x1bbc: 0x0002, 0x1bbd: 0x0002, 0x1bbe: 0x0002, 0x1bbf: 0x0002, + // Block 0x6f, offset 0x1bc0 + 0x1bc0: 0x0002, 0x1bc1: 0x0002, 0x1bc2: 0x0002, 0x1bc3: 0x0002, 0x1bc4: 0x0002, 0x1bc5: 0x0002, + 0x1bc6: 0x0002, 0x1bc7: 0x0002, 0x1bc8: 0x0002, 0x1bc9: 0x0002, 0x1bca: 0x0002, 0x1bcb: 0x0002, + 0x1bcc: 0x0002, 0x1bcd: 0x0002, 0x1bce: 0x0002, 0x1bcf: 0x0002, 0x1bd0: 0x0002, 0x1bd1: 0x0002, + 0x1bd2: 0x0002, 0x1bd3: 0x0002, 0x1bd4: 0x0002, 0x1bd5: 0x0002, 0x1bd6: 0x0002, 0x1bd7: 0x0002, + 0x1bd8: 0x0002, 0x1bd9: 0x0002, 0x1bda: 0x0002, 0x1bdb: 0x0002, 0x1bdc: 0x0002, 0x1bdd: 0x0002, + 0x1bde: 0x0002, 0x1bdf: 0x0002, 0x1be0: 0x0002, 0x1be1: 0x0002, 0x1be2: 0x0002, 0x1be3: 0x0002, + 0x1be4: 0x0002, 0x1be5: 0x0002, 0x1be6: 0x0002, 0x1be7: 0x0002, 0x1be8: 0x0002, 0x1be9: 0x0002, + 0x1bea: 0x0002, 0x1beb: 0x0002, 0x1bec: 0x0002, 0x1bed: 0x0002, 0x1bee: 0x0002, 0x1bef: 0x0002, + 0x1bf0: 0x0002, 0x1bf1: 0x0002, 0x1bf2: 0x0002, 0x1bf3: 0x0002, + // Block 0x70, offset 0x1c00 + 0x1c00: 0x0002, 0x1c01: 0x0002, 0x1c02: 0x0002, 0x1c03: 0x0002, 0x1c04: 0x0002, 0x1c05: 0x0002, + 0x1c06: 0x0002, 0x1c07: 0x0002, 0x1c08: 0x0002, 0x1c09: 0x0002, 0x1c0a: 0x0002, 0x1c0b: 0x0002, + 0x1c0c: 0x0002, 0x1c0d: 0x0002, 0x1c0e: 0x0002, 0x1c0f: 0x0002, 0x1c10: 0x0002, 0x1c11: 0x0002, + 0x1c12: 0x0002, 0x1c13: 0x0002, 0x1c14: 0x0002, 0x1c15: 0x0002, + 0x1c30: 0x0002, 0x1c31: 0x0002, 0x1c32: 0x0002, 0x1c33: 0x0002, 0x1c34: 0x0002, 0x1c35: 0x0002, + 0x1c36: 0x0002, 0x1c37: 0x0002, 0x1c38: 0x0002, 0x1c39: 0x0002, 0x1c3a: 0x0002, 0x1c3b: 0x0002, + 0x1c3c: 0x0002, 0x1c3d: 0x0002, 0x1c3e: 0x0002, 0x1c3f: 0x0002, + // Block 0x71, offset 0x1c40 + 0x1c40: 0x0002, 0x1c41: 0x0002, 0x1c42: 0x0002, 0x1c43: 0x0002, 0x1c44: 0x0002, 0x1c45: 0x0002, + 0x1c46: 0x0002, 0x1c47: 0x0002, 0x1c48: 0x0002, 0x1c49: 0x0002, 0x1c4a: 0x0002, 0x1c4b: 0x0002, + 0x1c4c: 0x0002, 0x1c4d: 0x0002, 0x1c4e: 0x0002, 0x1c4f: 0x0002, 0x1c50: 0x0002, 0x1c51: 0x0002, + 0x1c52: 0x0002, 0x1c53: 0x0002, 0x1c54: 0x0002, 0x1c55: 0x0002, 0x1c56: 0x0002, 0x1c57: 0x0002, + 0x1c58: 0x0002, 0x1c59: 0x0002, 0x1c5a: 0x0002, 0x1c5b: 0x0002, 0x1c5c: 0x0002, 0x1c5d: 0x0002, + 0x1c5e: 0x0002, 0x1c5f: 0x0002, 0x1c60: 0x0002, 0x1c61: 0x0002, 0x1c62: 0x0002, 0x1c63: 0x0002, + 0x1c64: 0x0002, 0x1c65: 0x0002, 0x1c66: 0x0002, 0x1c67: 0x0002, 0x1c68: 0x0002, 0x1c69: 0x0002, + 0x1c6a: 0x0001, 0x1c6b: 0x0001, 0x1c6c: 0x0001, 0x1c6d: 0x0001, 0x1c6e: 0x0002, 0x1c6f: 0x0002, + 0x1c70: 0x0002, 0x1c71: 0x0002, 0x1c72: 0x0002, 0x1c73: 0x0002, 0x1c74: 0x0002, 0x1c75: 0x0002, + 0x1c76: 0x0002, 0x1c77: 0x0002, 0x1c78: 0x0002, 0x1c79: 0x0002, 0x1c7a: 0x0002, 0x1c7b: 0x0002, + 0x1c7c: 0x0002, 0x1c7d: 0x0002, 0x1c7e: 0x0002, + // Block 0x72, offset 0x1c80 + 0x1c81: 0x0002, 0x1c82: 0x0002, 0x1c83: 0x0002, 0x1c84: 0x0002, 0x1c85: 0x0002, + 0x1c86: 0x0002, 0x1c87: 0x0002, 0x1c88: 0x0002, 0x1c89: 0x0002, 0x1c8a: 0x0002, 0x1c8b: 0x0002, + 0x1c8c: 0x0002, 0x1c8d: 0x0002, 0x1c8e: 0x0002, 0x1c8f: 0x0002, 0x1c90: 0x0002, 0x1c91: 0x0002, + 0x1c92: 0x0002, 0x1c93: 0x0002, 0x1c94: 0x0002, 0x1c95: 0x0002, 0x1c96: 0x0002, 0x1c97: 0x0002, + 0x1c98: 0x0002, 0x1c99: 0x0002, 0x1c9a: 0x0002, 0x1c9b: 0x0002, 0x1c9c: 0x0002, 0x1c9d: 0x0002, + 0x1c9e: 0x0002, 0x1c9f: 0x0002, 0x1ca0: 0x0002, 0x1ca1: 0x0002, 0x1ca2: 0x0002, 0x1ca3: 0x0002, + 0x1ca4: 0x0002, 0x1ca5: 0x0002, 0x1ca6: 0x0002, 0x1ca7: 0x0002, 0x1ca8: 0x0002, 0x1ca9: 0x0002, + 0x1caa: 0x0002, 0x1cab: 0x0002, 0x1cac: 0x0002, 0x1cad: 0x0002, 0x1cae: 0x0002, 0x1caf: 0x0002, + 0x1cb0: 0x0002, 0x1cb1: 0x0002, 0x1cb2: 0x0002, 0x1cb3: 0x0002, 0x1cb4: 0x0002, 0x1cb5: 0x0002, + 0x1cb6: 0x0002, 0x1cb7: 0x0002, 0x1cb8: 0x0002, 0x1cb9: 0x0002, 0x1cba: 0x0002, 0x1cbb: 0x0002, + 0x1cbc: 0x0002, 0x1cbd: 0x0002, 0x1cbe: 0x0002, 0x1cbf: 0x0002, + // Block 0x73, offset 0x1cc0 + 0x1cc0: 0x0002, 0x1cc1: 0x0002, 0x1cc2: 0x0002, 0x1cc3: 0x0002, 0x1cc4: 0x0002, 0x1cc5: 0x0002, + 0x1cc6: 0x0002, 0x1cc7: 0x0002, 0x1cc8: 0x0002, 0x1cc9: 0x0002, 0x1cca: 0x0002, 0x1ccb: 0x0002, + 0x1ccc: 0x0002, 0x1ccd: 0x0002, 0x1cce: 0x0002, 0x1ccf: 0x0002, 0x1cd0: 0x0002, 0x1cd1: 0x0002, + 0x1cd2: 0x0002, 0x1cd3: 0x0002, 0x1cd4: 0x0002, 0x1cd5: 0x0002, 0x1cd6: 0x0002, + 0x1cd9: 0x0001, 0x1cda: 0x0001, 0x1cdb: 0x0002, 0x1cdc: 0x0002, 0x1cdd: 0x0002, + 0x1cde: 0x0002, 0x1cdf: 0x0002, 0x1ce0: 0x0002, 0x1ce1: 0x0002, 0x1ce2: 0x0002, 0x1ce3: 0x0002, + 0x1ce4: 0x0002, 0x1ce5: 0x0002, 0x1ce6: 0x0002, 0x1ce7: 0x0002, 0x1ce8: 0x0002, 0x1ce9: 0x0002, + 0x1cea: 0x0002, 0x1ceb: 0x0002, 0x1cec: 0x0002, 0x1ced: 0x0002, 0x1cee: 0x0002, 0x1cef: 0x0002, + 0x1cf0: 0x0002, 0x1cf1: 0x0002, 0x1cf2: 0x0002, 0x1cf3: 0x0002, 0x1cf4: 0x0002, 0x1cf5: 0x0002, + 0x1cf6: 0x0002, 0x1cf7: 0x0002, 0x1cf8: 0x0002, 0x1cf9: 0x0002, 0x1cfa: 0x0002, 0x1cfb: 0x0002, + 0x1cfc: 0x0002, 0x1cfd: 0x0002, 0x1cfe: 0x0002, 0x1cff: 0x0002, + // Block 0x74, offset 0x1d00 + 0x1d05: 0x0002, + 0x1d06: 0x0002, 0x1d07: 0x0002, 0x1d08: 0x0002, 0x1d09: 0x0002, 0x1d0a: 0x0002, 0x1d0b: 0x0002, + 0x1d0c: 0x0002, 0x1d0d: 0x0002, 0x1d0e: 0x0002, 0x1d0f: 0x0002, 0x1d10: 0x0002, 0x1d11: 0x0002, + 0x1d12: 0x0002, 0x1d13: 0x0002, 0x1d14: 0x0002, 0x1d15: 0x0002, 0x1d16: 0x0002, 0x1d17: 0x0002, + 0x1d18: 0x0002, 0x1d19: 0x0002, 0x1d1a: 0x0002, 0x1d1b: 0x0002, 0x1d1c: 0x0002, 0x1d1d: 0x0002, + 0x1d1e: 0x0002, 0x1d1f: 0x0002, 0x1d20: 0x0002, 0x1d21: 0x0002, 0x1d22: 0x0002, 0x1d23: 0x0002, + 0x1d24: 0x0002, 0x1d25: 0x0002, 0x1d26: 0x0002, 0x1d27: 0x0002, 0x1d28: 0x0002, 0x1d29: 0x0002, + 0x1d2a: 0x0002, 0x1d2b: 0x0002, 0x1d2c: 0x0002, 0x1d2d: 0x0002, 0x1d2e: 0x0002, 0x1d2f: 0x0002, + 0x1d31: 0x0002, 0x1d32: 0x0002, 0x1d33: 0x0002, 0x1d34: 0x0002, 0x1d35: 0x0002, + 0x1d36: 0x0002, 0x1d37: 0x0002, 0x1d38: 0x0002, 0x1d39: 0x0002, 0x1d3a: 0x0002, 0x1d3b: 0x0002, + 0x1d3c: 0x0002, 0x1d3d: 0x0002, 0x1d3e: 0x0002, 0x1d3f: 0x0002, + // Block 0x75, offset 0x1d40 + 0x1d40: 0x0002, 0x1d41: 0x0002, 0x1d42: 0x0002, 0x1d43: 0x0002, 0x1d44: 0x0002, 0x1d45: 0x0002, + 0x1d46: 0x0002, 0x1d47: 0x0002, 0x1d48: 0x0002, 0x1d49: 0x0002, 0x1d4a: 0x0002, 0x1d4b: 0x0002, + 0x1d4c: 0x0002, 0x1d4d: 0x0002, 0x1d4e: 0x0002, 0x1d50: 0x0002, 0x1d51: 0x0002, + 0x1d52: 0x0002, 0x1d53: 0x0002, 0x1d54: 0x0002, 0x1d55: 0x0002, 0x1d56: 0x0002, 0x1d57: 0x0002, + 0x1d58: 0x0002, 0x1d59: 0x0002, 0x1d5a: 0x0002, 0x1d5b: 0x0002, 0x1d5c: 0x0002, 0x1d5d: 0x0002, + 0x1d5e: 0x0002, 0x1d5f: 0x0002, 0x1d60: 0x0002, 0x1d61: 0x0002, 0x1d62: 0x0002, 0x1d63: 0x0002, + 0x1d64: 0x0002, 0x1d65: 0x0002, 0x1d66: 0x0002, 0x1d67: 0x0002, 0x1d68: 0x0002, 0x1d69: 0x0002, + 0x1d6a: 0x0002, 0x1d6b: 0x0002, 0x1d6c: 0x0002, 0x1d6d: 0x0002, 0x1d6e: 0x0002, 0x1d6f: 0x0002, + 0x1d70: 0x0002, 0x1d71: 0x0002, 0x1d72: 0x0002, 0x1d73: 0x0002, 0x1d74: 0x0002, 0x1d75: 0x0002, + 0x1d76: 0x0002, 0x1d77: 0x0002, 0x1d78: 0x0002, 0x1d79: 0x0002, 0x1d7a: 0x0002, 0x1d7b: 0x0002, + 0x1d7c: 0x0002, 0x1d7d: 0x0002, 0x1d7e: 0x0002, 0x1d7f: 0x0002, + // Block 0x76, offset 0x1d80 + 0x1d80: 0x0002, 0x1d81: 0x0002, 0x1d82: 0x0002, 0x1d83: 0x0002, 0x1d84: 0x0002, 0x1d85: 0x0002, + 0x1d86: 0x0002, 0x1d87: 0x0002, 0x1d88: 0x0002, 0x1d89: 0x0002, 0x1d8a: 0x0002, 0x1d8b: 0x0002, + 0x1d8c: 0x0002, 0x1d8d: 0x0002, 0x1d8e: 0x0002, 0x1d8f: 0x0002, 0x1d90: 0x0002, 0x1d91: 0x0002, + 0x1d92: 0x0002, 0x1d93: 0x0002, 0x1d94: 0x0002, 0x1d95: 0x0002, 0x1d96: 0x0002, 0x1d97: 0x0002, + 0x1d98: 0x0002, 0x1d99: 0x0002, 0x1d9a: 0x0002, 0x1d9b: 0x0002, 0x1d9c: 0x0002, 0x1d9d: 0x0002, + 0x1d9e: 0x0002, 0x1d9f: 0x0002, 0x1da0: 0x0002, 0x1da1: 0x0002, 0x1da2: 0x0002, 0x1da3: 0x0002, + 0x1da4: 0x0002, 0x1da5: 0x0002, + 0x1daf: 0x0002, + 0x1db0: 0x0002, 0x1db1: 0x0002, 0x1db2: 0x0002, 0x1db3: 0x0002, 0x1db4: 0x0002, 0x1db5: 0x0002, + 0x1db6: 0x0002, 0x1db7: 0x0002, 0x1db8: 0x0002, 0x1db9: 0x0002, 0x1dba: 0x0002, 0x1dbb: 0x0002, + 0x1dbc: 0x0002, 0x1dbd: 0x0002, 0x1dbe: 0x0002, 0x1dbf: 0x0002, + // Block 0x77, offset 0x1dc0 + 0x1dc0: 0x0002, 0x1dc1: 0x0002, 0x1dc2: 0x0002, 0x1dc3: 0x0002, 0x1dc4: 0x0002, 0x1dc5: 0x0002, + 0x1dc6: 0x0002, 0x1dc7: 0x0002, 0x1dc8: 0x0002, 0x1dc9: 0x0002, 0x1dca: 0x0002, 0x1dcb: 0x0002, + 0x1dcc: 0x0002, 0x1dcd: 0x0002, 0x1dce: 0x0002, 0x1dcf: 0x0002, 0x1dd0: 0x0002, 0x1dd1: 0x0002, + 0x1dd2: 0x0002, 0x1dd3: 0x0002, 0x1dd4: 0x0002, 0x1dd5: 0x0002, 0x1dd6: 0x0002, 0x1dd7: 0x0002, + 0x1dd8: 0x0002, 0x1dd9: 0x0002, 0x1dda: 0x0002, 0x1ddb: 0x0002, 0x1ddc: 0x0002, 0x1ddd: 0x0002, + 0x1dde: 0x0002, 0x1de0: 0x0002, 0x1de1: 0x0002, 0x1de2: 0x0002, 0x1de3: 0x0002, + 0x1de4: 0x0002, 0x1de5: 0x0002, 0x1de6: 0x0002, 0x1de7: 0x0002, 0x1de8: 0x0002, 0x1de9: 0x0002, + 0x1dea: 0x0002, 0x1deb: 0x0002, 0x1dec: 0x0002, 0x1ded: 0x0002, 0x1dee: 0x0002, 0x1def: 0x0002, + 0x1df0: 0x0002, 0x1df1: 0x0002, 0x1df2: 0x0002, 0x1df3: 0x0002, 0x1df4: 0x0002, 0x1df5: 0x0002, + 0x1df6: 0x0002, 0x1df7: 0x0002, 0x1df8: 0x0002, 0x1df9: 0x0002, 0x1dfa: 0x0002, 0x1dfb: 0x0002, + 0x1dfc: 0x0002, 0x1dfd: 0x0002, 0x1dfe: 0x0002, 0x1dff: 0x0002, + // Block 0x78, offset 0x1e00 + 0x1e00: 0x0002, 0x1e01: 0x0002, 0x1e02: 0x0002, 0x1e03: 0x0002, 0x1e04: 0x0002, 0x1e05: 0x0002, + 0x1e06: 0x0002, 0x1e07: 0x0002, 0x1e08: 0x0003, 0x1e09: 0x0003, 0x1e0a: 0x0003, 0x1e0b: 0x0003, + 0x1e0c: 0x0003, 0x1e0d: 0x0003, 0x1e0e: 0x0003, 0x1e0f: 0x0003, 0x1e10: 0x0002, 0x1e11: 0x0002, + 0x1e12: 0x0002, 0x1e13: 0x0002, 0x1e14: 0x0002, 0x1e15: 0x0002, 0x1e16: 0x0002, 0x1e17: 0x0002, + 0x1e18: 0x0002, 0x1e19: 0x0002, 0x1e1a: 0x0002, 0x1e1b: 0x0002, 0x1e1c: 0x0002, 0x1e1d: 0x0002, + 0x1e1e: 0x0002, 0x1e1f: 0x0002, 0x1e20: 0x0002, 0x1e21: 0x0002, 0x1e22: 0x0002, 0x1e23: 0x0002, + 0x1e24: 0x0002, 0x1e25: 0x0002, 0x1e26: 0x0002, 0x1e27: 0x0002, 0x1e28: 0x0002, 0x1e29: 0x0002, + 0x1e2a: 0x0002, 0x1e2b: 0x0002, 0x1e2c: 0x0002, 0x1e2d: 0x0002, 0x1e2e: 0x0002, 0x1e2f: 0x0002, + 0x1e30: 0x0002, 0x1e31: 0x0002, 0x1e32: 0x0002, 0x1e33: 0x0002, 0x1e34: 0x0002, 0x1e35: 0x0002, + 0x1e36: 0x0002, 0x1e37: 0x0002, 0x1e38: 0x0002, 0x1e39: 0x0002, 0x1e3a: 0x0002, 0x1e3b: 0x0002, + 0x1e3c: 0x0002, 0x1e3d: 0x0002, 0x1e3e: 0x0002, 0x1e3f: 0x0002, + // Block 0x79, offset 0x1e40 + 0x1e40: 0x0002, 0x1e41: 0x0002, 0x1e42: 0x0002, 0x1e43: 0x0002, 0x1e44: 0x0002, 0x1e45: 0x0002, + 0x1e46: 0x0002, 0x1e47: 0x0002, 0x1e48: 0x0002, 0x1e49: 0x0002, 0x1e4a: 0x0002, 0x1e4b: 0x0002, + 0x1e4c: 0x0002, 0x1e50: 0x0002, 0x1e51: 0x0002, + 0x1e52: 0x0002, 0x1e53: 0x0002, 0x1e54: 0x0002, 0x1e55: 0x0002, 0x1e56: 0x0002, 0x1e57: 0x0002, + 0x1e58: 0x0002, 0x1e59: 0x0002, 0x1e5a: 0x0002, 0x1e5b: 0x0002, 0x1e5c: 0x0002, 0x1e5d: 0x0002, + 0x1e5e: 0x0002, 0x1e5f: 0x0002, 0x1e60: 0x0002, 0x1e61: 0x0002, 0x1e62: 0x0002, 0x1e63: 0x0002, + 0x1e64: 0x0002, 0x1e65: 0x0002, 0x1e66: 0x0002, 0x1e67: 0x0002, 0x1e68: 0x0002, 0x1e69: 0x0002, + 0x1e6a: 0x0002, 0x1e6b: 0x0002, 0x1e6c: 0x0002, 0x1e6d: 0x0002, 0x1e6e: 0x0002, 0x1e6f: 0x0002, + 0x1e70: 0x0002, 0x1e71: 0x0002, 0x1e72: 0x0002, 0x1e73: 0x0002, 0x1e74: 0x0002, 0x1e75: 0x0002, + 0x1e76: 0x0002, 0x1e77: 0x0002, 0x1e78: 0x0002, 0x1e79: 0x0002, 0x1e7a: 0x0002, 0x1e7b: 0x0002, + 0x1e7c: 0x0002, 0x1e7d: 0x0002, 0x1e7e: 0x0002, 0x1e7f: 0x0002, + // Block 0x7a, offset 0x1e80 + 0x1e80: 0x0002, 0x1e81: 0x0002, 0x1e82: 0x0002, 0x1e83: 0x0002, 0x1e84: 0x0002, 0x1e85: 0x0002, + 0x1e86: 0x0002, + // Block 0x7b, offset 0x1ec0 + 0x1eef: 0x0001, + 0x1ef0: 0x0001, 0x1ef1: 0x0001, 0x1ef2: 0x0001, 0x1ef4: 0x0001, 0x1ef5: 0x0001, + 0x1ef6: 0x0001, 0x1ef7: 0x0001, 0x1ef8: 0x0001, 0x1ef9: 0x0001, 0x1efa: 0x0001, 0x1efb: 0x0001, + 0x1efc: 0x0001, 0x1efd: 0x0001, + // Block 0x7c, offset 0x1f00 + 0x1f1e: 0x0001, 0x1f1f: 0x0001, + // Block 0x7d, offset 0x1f40 + 0x1f70: 0x0001, 0x1f71: 0x0001, + // Block 0x7e, offset 0x1f80 + 0x1f82: 0x0001, + 0x1f86: 0x0001, 0x1f8b: 0x0001, + 0x1fa5: 0x0001, 0x1fa6: 0x0001, + 0x1fac: 0x0001, + // Block 0x7f, offset 0x1fc0 + 0x1fc4: 0x0001, 0x1fc5: 0x0001, + 0x1fe0: 0x0001, 0x1fe1: 0x0001, 0x1fe2: 0x0001, 0x1fe3: 0x0001, + 0x1fe4: 0x0001, 0x1fe5: 0x0001, 0x1fe6: 0x0001, 0x1fe7: 0x0001, 0x1fe8: 0x0001, 0x1fe9: 0x0001, + 0x1fea: 0x0001, 0x1feb: 0x0001, 0x1fec: 0x0001, 0x1fed: 0x0001, 0x1fee: 0x0001, 0x1fef: 0x0001, + 0x1ff0: 0x0001, 0x1ff1: 0x0001, + 0x1fff: 0x0001, + // Block 0x80, offset 0x2000 + 0x2026: 0x0001, 0x2027: 0x0001, 0x2028: 0x0001, 0x2029: 0x0001, + 0x202a: 0x0001, 0x202b: 0x0001, 0x202c: 0x0001, 0x202d: 0x0001, + // Block 0x81, offset 0x2040 + 0x2047: 0x0001, 0x2048: 0x0001, 0x2049: 0x0001, 0x204a: 0x0001, 0x204b: 0x0001, + 0x204c: 0x0001, 0x204d: 0x0001, 0x204e: 0x0001, 0x204f: 0x0001, 0x2050: 0x0001, 0x2051: 0x0001, + 0x2060: 0x0002, 0x2061: 0x0002, 0x2062: 0x0002, 0x2063: 0x0002, + 0x2064: 0x0002, 0x2065: 0x0002, 0x2066: 0x0002, 0x2067: 0x0002, 0x2068: 0x0002, 0x2069: 0x0002, + 0x206a: 0x0002, 0x206b: 0x0002, 0x206c: 0x0002, 0x206d: 0x0002, 0x206e: 0x0002, 0x206f: 0x0002, + 0x2070: 0x0002, 0x2071: 0x0002, 0x2072: 0x0002, 0x2073: 0x0002, 0x2074: 0x0002, 0x2075: 0x0002, + 0x2076: 0x0002, 0x2077: 0x0002, 0x2078: 0x0002, 0x2079: 0x0002, 0x207a: 0x0002, 0x207b: 0x0002, + 0x207c: 0x0002, + // Block 0x82, offset 0x2080 + 0x2080: 0x0001, 0x2081: 0x0001, 0x2082: 0x0001, + 0x20b3: 0x0001, + 0x20b6: 0x0001, 0x20b7: 0x0001, 0x20b8: 0x0001, 0x20b9: 0x0001, + 0x20bc: 0x0001, 0x20bd: 0x0001, + // Block 0x83, offset 0x20c0 + 0x20e5: 0x0001, + // Block 0x84, offset 0x2100 + 0x2129: 0x0001, + 0x212a: 0x0001, 0x212b: 0x0001, 0x212c: 0x0001, 0x212d: 0x0001, 0x212e: 0x0001, + 0x2131: 0x0001, 0x2132: 0x0001, 0x2135: 0x0001, + 0x2136: 0x0001, + // Block 0x85, offset 0x2140 + 0x2143: 0x0001, + 0x214c: 0x0001, + 0x217c: 0x0001, + // Block 0x86, offset 0x2180 + 0x21b0: 0x0001, 0x21b2: 0x0001, 0x21b3: 0x0001, 0x21b4: 0x0001, + 0x21b7: 0x0001, 0x21b8: 0x0001, + 0x21be: 0x0001, 0x21bf: 0x0001, + // Block 0x87, offset 0x21c0 + 0x21c1: 0x0001, + 0x21ec: 0x0001, 0x21ed: 0x0001, + 0x21f6: 0x0001, + // Block 0x88, offset 0x2200 + 0x2225: 0x0001, 0x2228: 0x0001, + 0x222d: 0x0001, + // Block 0x89, offset 0x2240 + 0x2240: 0x0002, 0x2241: 0x0002, 0x2242: 0x0002, 0x2243: 0x0002, 0x2244: 0x0002, 0x2245: 0x0002, + 0x2246: 0x0002, 0x2247: 0x0002, 0x2248: 0x0002, 0x2249: 0x0002, 0x224a: 0x0002, 0x224b: 0x0002, + 0x224c: 0x0002, 0x224d: 0x0002, 0x224e: 0x0002, 0x224f: 0x0002, 0x2250: 0x0002, 0x2251: 0x0002, + 0x2252: 0x0002, 0x2253: 0x0002, 0x2254: 0x0002, 0x2255: 0x0002, 0x2256: 0x0002, 0x2257: 0x0002, + 0x2258: 0x0002, 0x2259: 0x0002, 0x225a: 0x0002, 0x225b: 0x0002, 0x225c: 0x0002, 0x225d: 0x0002, + 0x225e: 0x0002, 0x225f: 0x0002, 0x2260: 0x0002, 0x2261: 0x0002, 0x2262: 0x0002, 0x2263: 0x0002, + // Block 0x8a, offset 0x2280 + 0x229e: 0x0001, + // Block 0x8b, offset 0x22c0 + 0x22c0: 0x0001, 0x22c1: 0x0001, 0x22c2: 0x0001, 0x22c3: 0x0001, 0x22c4: 0x0001, 0x22c5: 0x0001, + 0x22c6: 0x0001, 0x22c7: 0x0001, 0x22c8: 0x0001, 0x22c9: 0x0001, 0x22ca: 0x0001, 0x22cb: 0x0001, + 0x22cc: 0x0001, 0x22cd: 0x0001, 0x22ce: 0x0001, 0x22cf: 0x0001, 0x22d0: 0x0002, 0x22d1: 0x0002, + 0x22d2: 0x0002, 0x22d3: 0x0002, 0x22d4: 0x0002, 0x22d5: 0x0002, 0x22d6: 0x0002, 0x22d7: 0x0002, + 0x22d8: 0x0002, 0x22d9: 0x0002, + 0x22e0: 0x0001, 0x22e1: 0x0001, 0x22e2: 0x0001, 0x22e3: 0x0001, + 0x22e4: 0x0001, 0x22e5: 0x0001, 0x22e6: 0x0001, 0x22e7: 0x0001, 0x22e8: 0x0001, 0x22e9: 0x0001, + 0x22ea: 0x0001, 0x22eb: 0x0001, 0x22ec: 0x0001, 0x22ed: 0x0001, 0x22ee: 0x0001, 0x22ef: 0x0001, + 0x22f0: 0x0002, 0x22f1: 0x0002, 0x22f2: 0x0002, 0x22f3: 0x0002, 0x22f4: 0x0002, 0x22f5: 0x0002, + 0x22f6: 0x0002, 0x22f7: 0x0002, 0x22f8: 0x0002, 0x22f9: 0x0002, 0x22fa: 0x0002, 0x22fb: 0x0002, + 0x22fc: 0x0002, 0x22fd: 0x0002, 0x22fe: 0x0002, 0x22ff: 0x0002, + // Block 0x8c, offset 0x2300 + 0x2300: 0x0002, 0x2301: 0x0002, 0x2302: 0x0002, 0x2303: 0x0002, 0x2304: 0x0002, 0x2305: 0x0002, + 0x2306: 0x0002, 0x2307: 0x0002, 0x2308: 0x0002, 0x2309: 0x0002, 0x230a: 0x0002, 0x230b: 0x0002, + 0x230c: 0x0002, 0x230d: 0x0002, 0x230e: 0x0002, 0x230f: 0x0002, 0x2310: 0x0002, 0x2311: 0x0002, + 0x2312: 0x0002, 0x2314: 0x0002, 0x2315: 0x0002, 0x2316: 0x0002, 0x2317: 0x0002, + 0x2318: 0x0002, 0x2319: 0x0002, 0x231a: 0x0002, 0x231b: 0x0002, 0x231c: 0x0002, 0x231d: 0x0002, + 0x231e: 0x0002, 0x231f: 0x0002, 0x2320: 0x0002, 0x2321: 0x0002, 0x2322: 0x0002, 0x2323: 0x0002, + 0x2324: 0x0002, 0x2325: 0x0002, 0x2326: 0x0002, 0x2328: 0x0002, 0x2329: 0x0002, + 0x232a: 0x0002, 0x232b: 0x0002, + // Block 0x8d, offset 0x2340 + 0x2340: 0x0002, 0x2341: 0x0002, 0x2342: 0x0002, 0x2343: 0x0002, 0x2344: 0x0002, 0x2345: 0x0002, + 0x2346: 0x0002, 0x2347: 0x0002, 0x2348: 0x0002, 0x2349: 0x0002, 0x234a: 0x0002, 0x234b: 0x0002, + 0x234c: 0x0002, 0x234d: 0x0002, 0x234e: 0x0002, 0x234f: 0x0002, 0x2350: 0x0002, 0x2351: 0x0002, + 0x2352: 0x0002, 0x2353: 0x0002, 0x2354: 0x0002, 0x2355: 0x0002, 0x2356: 0x0002, 0x2357: 0x0002, + 0x2358: 0x0002, 0x2359: 0x0002, 0x235a: 0x0002, 0x235b: 0x0002, 0x235c: 0x0002, 0x235d: 0x0002, + 0x235e: 0x0002, 0x235f: 0x0002, 0x2360: 0x0002, + // Block 0x8e, offset 0x2380 + 0x23a0: 0x0002, 0x23a1: 0x0002, 0x23a2: 0x0002, 0x23a3: 0x0002, + 0x23a4: 0x0002, 0x23a5: 0x0002, 0x23a6: 0x0002, + 0x23b9: 0x0001, 0x23ba: 0x0001, 0x23bb: 0x0001, + 0x23be: 0x0001, 0x23bf: 0x0001, + // Block 0x8f, offset 0x23c0 + 0x23fd: 0x0001, + // Block 0x90, offset 0x2400 + 0x2420: 0x0001, + // Block 0x91, offset 0x2440 + 0x2476: 0x0001, 0x2477: 0x0001, 0x2478: 0x0001, 0x2479: 0x0001, 0x247a: 0x0001, + // Block 0x92, offset 0x2480 + 0x2481: 0x0001, 0x2482: 0x0001, 0x2483: 0x0001, 0x2485: 0x0001, + 0x2486: 0x0001, + 0x248c: 0x0001, 0x248d: 0x0001, 0x248e: 0x0001, 0x248f: 0x0001, + 0x24b8: 0x0001, 0x24b9: 0x0001, 0x24ba: 0x0001, + 0x24bf: 0x0001, + // Block 0x93, offset 0x24c0 + 0x24e5: 0x0001, 0x24e6: 0x0001, + // Block 0x94, offset 0x2500 + 0x2524: 0x0001, 0x2525: 0x0001, 0x2526: 0x0001, 0x2527: 0x0001, + // Block 0x95, offset 0x2540 + 0x256b: 0x0001, 0x256c: 0x0001, + // Block 0x96, offset 0x2580 + 0x25bd: 0x0001, 0x25be: 0x0001, 0x25bf: 0x0001, + // Block 0x97, offset 0x25c0 + 0x25c6: 0x0001, 0x25c7: 0x0001, 0x25c8: 0x0001, 0x25c9: 0x0001, 0x25ca: 0x0001, 0x25cb: 0x0001, + 0x25cc: 0x0001, 0x25cd: 0x0001, 0x25ce: 0x0001, 0x25cf: 0x0001, 0x25d0: 0x0001, + // Block 0x98, offset 0x2600 + 0x2602: 0x0001, 0x2603: 0x0001, 0x2604: 0x0001, 0x2605: 0x0001, + // Block 0x99, offset 0x2640 + 0x2641: 0x0001, + 0x2678: 0x0001, 0x2679: 0x0001, 0x267a: 0x0001, 0x267b: 0x0001, + 0x267c: 0x0001, 0x267d: 0x0001, 0x267e: 0x0001, 0x267f: 0x0001, + // Block 0x9a, offset 0x2680 + 0x2680: 0x0001, 0x2681: 0x0001, 0x2682: 0x0001, 0x2683: 0x0001, 0x2684: 0x0001, 0x2685: 0x0001, + 0x2686: 0x0001, + 0x26b0: 0x0001, 0x26b3: 0x0001, 0x26b4: 0x0001, + 0x26bf: 0x0001, + // Block 0x9b, offset 0x26c0 + 0x26c0: 0x0001, 0x26c1: 0x0001, + 0x26f3: 0x0001, 0x26f4: 0x0001, 0x26f5: 0x0001, + 0x26f6: 0x0001, 0x26f9: 0x0001, 0x26fa: 0x0001, + 0x26fd: 0x0001, + // Block 0x9c, offset 0x2700 + 0x2702: 0x0001, + 0x270d: 0x0001, + // Block 0x9d, offset 0x2740 + 0x2740: 0x0001, 0x2741: 0x0001, 0x2742: 0x0001, + 0x2767: 0x0001, 0x2768: 0x0001, 0x2769: 0x0001, + 0x276a: 0x0001, 0x276b: 0x0001, 0x276d: 0x0001, 0x276e: 0x0001, 0x276f: 0x0001, + 0x2770: 0x0001, 0x2771: 0x0001, 0x2772: 0x0001, 0x2773: 0x0001, 0x2774: 0x0001, + // Block 0x9e, offset 0x2780 + 0x27b3: 0x0001, + // Block 0x9f, offset 0x27c0 + 0x27c0: 0x0001, 0x27c1: 0x0001, + 0x27f6: 0x0001, 0x27f7: 0x0001, 0x27f8: 0x0001, 0x27f9: 0x0001, 0x27fa: 0x0001, 0x27fb: 0x0001, + 0x27fc: 0x0001, 0x27fd: 0x0001, 0x27fe: 0x0001, + // Block 0xa0, offset 0x2800 + 0x2809: 0x0001, 0x280a: 0x0001, 0x280b: 0x0001, + 0x280c: 0x0001, 0x280f: 0x0001, + // Block 0xa1, offset 0x2840 + 0x286f: 0x0001, + 0x2870: 0x0001, 0x2871: 0x0001, 0x2874: 0x0001, + 0x2876: 0x0001, 0x2877: 0x0001, + 0x287e: 0x0001, + // Block 0xa2, offset 0x2880 + 0x289f: 0x0001, 0x28a3: 0x0001, + 0x28a4: 0x0001, 0x28a5: 0x0001, 0x28a6: 0x0001, 0x28a7: 0x0001, 0x28a8: 0x0001, 0x28a9: 0x0001, + 0x28aa: 0x0001, + // Block 0xa3, offset 0x28c0 + 0x28c0: 0x0001, + 0x28e6: 0x0001, 0x28e7: 0x0001, 0x28e8: 0x0001, 0x28e9: 0x0001, + 0x28ea: 0x0001, 0x28eb: 0x0001, 0x28ec: 0x0001, + 0x28f0: 0x0001, 0x28f1: 0x0001, 0x28f2: 0x0001, 0x28f3: 0x0001, 0x28f4: 0x0001, + // Block 0xa4, offset 0x2900 + 0x2938: 0x0001, 0x2939: 0x0001, 0x293a: 0x0001, 0x293b: 0x0001, + 0x293c: 0x0001, 0x293d: 0x0001, 0x293e: 0x0001, 0x293f: 0x0001, + // Block 0xa5, offset 0x2940 + 0x2942: 0x0001, 0x2943: 0x0001, 0x2944: 0x0001, + 0x2946: 0x0001, + 0x295e: 0x0001, + // Block 0xa6, offset 0x2980 + 0x29b3: 0x0001, 0x29b4: 0x0001, 0x29b5: 0x0001, + 0x29b6: 0x0001, 0x29b7: 0x0001, 0x29b8: 0x0001, 0x29ba: 0x0001, + 0x29bf: 0x0001, + // Block 0xa7, offset 0x29c0 + 0x29c0: 0x0001, 0x29c2: 0x0001, 0x29c3: 0x0001, + // Block 0xa8, offset 0x2a00 + 0x2a32: 0x0001, 0x2a33: 0x0001, 0x2a34: 0x0001, 0x2a35: 0x0001, + 0x2a3c: 0x0001, 0x2a3d: 0x0001, 0x2a3f: 0x0001, + // Block 0xa9, offset 0x2a40 + 0x2a40: 0x0001, + 0x2a5c: 0x0001, 0x2a5d: 0x0001, + // Block 0xaa, offset 0x2a80 + 0x2ab3: 0x0001, 0x2ab4: 0x0001, 0x2ab5: 0x0001, + 0x2ab6: 0x0001, 0x2ab7: 0x0001, 0x2ab8: 0x0001, 0x2ab9: 0x0001, 0x2aba: 0x0001, + 0x2abd: 0x0001, 0x2abf: 0x0001, + // Block 0xab, offset 0x2ac0 + 0x2ac0: 0x0001, + // Block 0xac, offset 0x2b00 + 0x2b2b: 0x0001, 0x2b2d: 0x0001, + 0x2b30: 0x0001, 0x2b31: 0x0001, 0x2b32: 0x0001, 0x2b33: 0x0001, 0x2b34: 0x0001, 0x2b35: 0x0001, + 0x2b37: 0x0001, + // Block 0xad, offset 0x2b40 + 0x2b5d: 0x0001, + 0x2b5e: 0x0001, 0x2b5f: 0x0001, 0x2b62: 0x0001, 0x2b63: 0x0001, + 0x2b64: 0x0001, 0x2b65: 0x0001, 0x2b67: 0x0001, 0x2b68: 0x0001, 0x2b69: 0x0001, + 0x2b6a: 0x0001, 0x2b6b: 0x0001, + // Block 0xae, offset 0x2b80 + 0x2baf: 0x0001, + 0x2bb0: 0x0001, 0x2bb1: 0x0001, 0x2bb2: 0x0001, 0x2bb3: 0x0001, 0x2bb4: 0x0001, 0x2bb5: 0x0001, + 0x2bb6: 0x0001, 0x2bb7: 0x0001, 0x2bb9: 0x0001, 0x2bba: 0x0001, + // Block 0xaf, offset 0x2bc0 + 0x2bfb: 0x0001, + 0x2bfc: 0x0001, 0x2bfe: 0x0001, + // Block 0xb0, offset 0x2c00 + 0x2c03: 0x0001, + // Block 0xb1, offset 0x2c40 + 0x2c54: 0x0001, 0x2c55: 0x0001, 0x2c56: 0x0001, 0x2c57: 0x0001, + 0x2c5a: 0x0001, 0x2c5b: 0x0001, + 0x2c60: 0x0001, + // Block 0xb2, offset 0x2c80 + 0x2c81: 0x0001, 0x2c82: 0x0001, 0x2c83: 0x0001, 0x2c84: 0x0001, 0x2c85: 0x0001, + 0x2c86: 0x0001, 0x2c87: 0x0001, 0x2c88: 0x0001, 0x2c89: 0x0001, 0x2c8a: 0x0001, + 0x2cb3: 0x0001, 0x2cb4: 0x0001, 0x2cb5: 0x0001, + 0x2cb6: 0x0001, 0x2cb7: 0x0001, 0x2cb8: 0x0001, 0x2cbb: 0x0001, + 0x2cbc: 0x0001, 0x2cbd: 0x0001, 0x2cbe: 0x0001, + // Block 0xb3, offset 0x2cc0 + 0x2cc7: 0x0001, + 0x2cd1: 0x0001, + 0x2cd2: 0x0001, 0x2cd3: 0x0001, 0x2cd4: 0x0001, 0x2cd5: 0x0001, 0x2cd6: 0x0001, + 0x2cd9: 0x0001, 0x2cda: 0x0001, 0x2cdb: 0x0001, + // Block 0xb4, offset 0x2d00 + 0x2d0a: 0x0001, 0x2d0b: 0x0001, + 0x2d0c: 0x0001, 0x2d0d: 0x0001, 0x2d0e: 0x0001, 0x2d0f: 0x0001, 0x2d10: 0x0001, 0x2d11: 0x0001, + 0x2d12: 0x0001, 0x2d13: 0x0001, 0x2d14: 0x0001, 0x2d15: 0x0001, 0x2d16: 0x0001, + 0x2d18: 0x0001, 0x2d19: 0x0001, + // Block 0xb5, offset 0x2d40 + 0x2d70: 0x0001, 0x2d71: 0x0001, 0x2d72: 0x0001, 0x2d73: 0x0001, 0x2d74: 0x0001, 0x2d75: 0x0001, + 0x2d76: 0x0001, 0x2d78: 0x0001, 0x2d79: 0x0001, 0x2d7a: 0x0001, 0x2d7b: 0x0001, + 0x2d7c: 0x0001, 0x2d7d: 0x0001, 0x2d7f: 0x0001, + // Block 0xb6, offset 0x2d80 + 0x2d92: 0x0001, 0x2d93: 0x0001, 0x2d94: 0x0001, 0x2d95: 0x0001, 0x2d96: 0x0001, 0x2d97: 0x0001, + 0x2d98: 0x0001, 0x2d99: 0x0001, 0x2d9a: 0x0001, 0x2d9b: 0x0001, 0x2d9c: 0x0001, 0x2d9d: 0x0001, + 0x2d9e: 0x0001, 0x2d9f: 0x0001, 0x2da0: 0x0001, 0x2da1: 0x0001, 0x2da2: 0x0001, 0x2da3: 0x0001, + 0x2da4: 0x0001, 0x2da5: 0x0001, 0x2da6: 0x0001, 0x2da7: 0x0001, + 0x2daa: 0x0001, 0x2dab: 0x0001, 0x2dac: 0x0001, 0x2dad: 0x0001, 0x2dae: 0x0001, 0x2daf: 0x0001, + 0x2db0: 0x0001, 0x2db2: 0x0001, 0x2db3: 0x0001, 0x2db5: 0x0001, + 0x2db6: 0x0001, + // Block 0xb7, offset 0x2dc0 + 0x2df1: 0x0001, 0x2df2: 0x0001, 0x2df3: 0x0001, 0x2df4: 0x0001, 0x2df5: 0x0001, + 0x2df6: 0x0001, 0x2dfa: 0x0001, + 0x2dfc: 0x0001, 0x2dfd: 0x0001, 0x2dff: 0x0001, + // Block 0xb8, offset 0x2e00 + 0x2e00: 0x0001, 0x2e01: 0x0001, 0x2e02: 0x0001, 0x2e03: 0x0001, 0x2e04: 0x0001, 0x2e05: 0x0001, + 0x2e07: 0x0001, + // Block 0xb9, offset 0x2e40 + 0x2e50: 0x0001, 0x2e51: 0x0001, + 0x2e55: 0x0001, 0x2e57: 0x0001, + // Block 0xba, offset 0x2e80 + 0x2eb3: 0x0001, 0x2eb4: 0x0001, + // Block 0xbb, offset 0x2ec0 + 0x2ec0: 0x0001, 0x2ec1: 0x0001, + 0x2ef6: 0x0001, 0x2ef7: 0x0001, 0x2ef8: 0x0001, 0x2ef9: 0x0001, 0x2efa: 0x0001, + // Block 0xbc, offset 0x2f00 + 0x2f00: 0x0001, 0x2f02: 0x0001, + // Block 0xbd, offset 0x2f40 + 0x2f40: 0x0001, + 0x2f47: 0x0001, 0x2f48: 0x0001, 0x2f49: 0x0001, 0x2f4a: 0x0001, 0x2f4b: 0x0001, + 0x2f4c: 0x0001, 0x2f4d: 0x0001, 0x2f4e: 0x0001, 0x2f4f: 0x0001, 0x2f50: 0x0001, 0x2f51: 0x0001, + 0x2f52: 0x0001, 0x2f53: 0x0001, 0x2f54: 0x0001, 0x2f55: 0x0001, + // Block 0xbe, offset 0x2f80 + 0x2fb0: 0x0001, 0x2fb1: 0x0001, 0x2fb2: 0x0001, 0x2fb3: 0x0001, 0x2fb4: 0x0001, + // Block 0xbf, offset 0x2fc0 + 0x2ff0: 0x0001, 0x2ff1: 0x0001, 0x2ff2: 0x0001, 0x2ff3: 0x0001, 0x2ff4: 0x0001, 0x2ff5: 0x0001, + 0x2ff6: 0x0001, + // Block 0xc0, offset 0x3000 + 0x300f: 0x0001, + // Block 0xc1, offset 0x3040 + 0x304f: 0x0001, 0x3050: 0x0001, 0x3051: 0x0001, + 0x3052: 0x0001, + // Block 0xc2, offset 0x3080 + 0x30a0: 0x0002, 0x30a1: 0x0002, 0x30a2: 0x0002, 0x30a3: 0x0002, + 0x30a4: 0x0001, + 0x30b0: 0x0002, 0x30b1: 0x0002, 0x30b2: 0x0002, 0x30b3: 0x0002, 0x30b4: 0x0002, 0x30b5: 0x0002, + 0x30b6: 0x0002, + // Block 0xc3, offset 0x30c0 + 0x30c0: 0x0002, 0x30c1: 0x0002, 0x30c2: 0x0002, 0x30c3: 0x0002, 0x30c4: 0x0002, 0x30c5: 0x0002, + 0x30c6: 0x0002, 0x30c7: 0x0002, 0x30c8: 0x0002, 0x30c9: 0x0002, 0x30ca: 0x0002, 0x30cb: 0x0002, + 0x30cc: 0x0002, 0x30cd: 0x0002, 0x30ce: 0x0002, 0x30cf: 0x0002, 0x30d0: 0x0002, 0x30d1: 0x0002, + 0x30d2: 0x0002, 0x30d3: 0x0002, 0x30d4: 0x0002, 0x30d5: 0x0002, + 0x30ff: 0x0002, + // Block 0xc4, offset 0x3100 + 0x3100: 0x0002, 0x3101: 0x0002, 0x3102: 0x0002, 0x3103: 0x0002, 0x3104: 0x0002, 0x3105: 0x0002, + 0x3106: 0x0002, 0x3107: 0x0002, 0x3108: 0x0002, 0x3109: 0x0002, 0x310a: 0x0002, 0x310b: 0x0002, + 0x310c: 0x0002, 0x310d: 0x0002, 0x310e: 0x0002, 0x310f: 0x0002, 0x3110: 0x0002, 0x3111: 0x0002, + 0x3112: 0x0002, 0x3113: 0x0002, 0x3114: 0x0002, 0x3115: 0x0002, 0x3116: 0x0002, 0x3117: 0x0002, + 0x3118: 0x0002, 0x3119: 0x0002, 0x311a: 0x0002, 0x311b: 0x0002, 0x311c: 0x0002, 0x311d: 0x0002, + 0x311e: 0x0002, + // Block 0xc5, offset 0x3140 + 0x3140: 0x0002, 0x3141: 0x0002, 0x3142: 0x0002, 0x3143: 0x0002, 0x3144: 0x0002, 0x3145: 0x0002, + 0x3146: 0x0002, 0x3147: 0x0002, 0x3148: 0x0002, 0x3149: 0x0002, 0x314a: 0x0002, 0x314b: 0x0002, + 0x314c: 0x0002, 0x314d: 0x0002, 0x314e: 0x0002, 0x314f: 0x0002, 0x3150: 0x0002, 0x3151: 0x0002, + 0x3152: 0x0002, 0x3153: 0x0002, 0x3154: 0x0002, 0x3155: 0x0002, 0x3156: 0x0002, 0x3157: 0x0002, + 0x3158: 0x0002, 0x3159: 0x0002, 0x315a: 0x0002, 0x315b: 0x0002, 0x315c: 0x0002, 0x315d: 0x0002, + 0x315e: 0x0002, 0x315f: 0x0002, 0x3160: 0x0002, 0x3161: 0x0002, 0x3162: 0x0002, 0x3163: 0x0002, + 0x3164: 0x0002, 0x3165: 0x0002, 0x3166: 0x0002, 0x3167: 0x0002, 0x3168: 0x0002, 0x3169: 0x0002, + 0x316a: 0x0002, 0x316b: 0x0002, 0x316c: 0x0002, 0x316d: 0x0002, 0x316e: 0x0002, 0x316f: 0x0002, + 0x3170: 0x0002, 0x3171: 0x0002, 0x3172: 0x0002, + // Block 0xc6, offset 0x3180 + 0x31b0: 0x0002, 0x31b1: 0x0002, 0x31b2: 0x0002, 0x31b3: 0x0002, 0x31b5: 0x0002, + 0x31b6: 0x0002, 0x31b7: 0x0002, 0x31b8: 0x0002, 0x31b9: 0x0002, 0x31ba: 0x0002, 0x31bb: 0x0002, + 0x31bd: 0x0002, 0x31be: 0x0002, + // Block 0xc7, offset 0x31c0 + 0x31c0: 0x0002, 0x31c1: 0x0002, 0x31c2: 0x0002, 0x31c3: 0x0002, 0x31c4: 0x0002, 0x31c5: 0x0002, + 0x31c6: 0x0002, 0x31c7: 0x0002, 0x31c8: 0x0002, 0x31c9: 0x0002, 0x31ca: 0x0002, 0x31cb: 0x0002, + 0x31cc: 0x0002, 0x31cd: 0x0002, 0x31ce: 0x0002, 0x31cf: 0x0002, 0x31d0: 0x0002, 0x31d1: 0x0002, + 0x31d2: 0x0002, 0x31d3: 0x0002, 0x31d4: 0x0002, 0x31d5: 0x0002, 0x31d6: 0x0002, 0x31d7: 0x0002, + 0x31d8: 0x0002, 0x31d9: 0x0002, 0x31da: 0x0002, 0x31db: 0x0002, 0x31dc: 0x0002, 0x31dd: 0x0002, + 0x31de: 0x0002, 0x31df: 0x0002, 0x31e0: 0x0002, 0x31e1: 0x0002, 0x31e2: 0x0002, + 0x31f2: 0x0002, + // Block 0xc8, offset 0x3200 + 0x3210: 0x0002, 0x3211: 0x0002, + 0x3212: 0x0002, 0x3215: 0x0002, + 0x3224: 0x0002, 0x3225: 0x0002, 0x3226: 0x0002, 0x3227: 0x0002, + 0x3230: 0x0002, 0x3231: 0x0002, 0x3232: 0x0002, 0x3233: 0x0002, 0x3234: 0x0002, 0x3235: 0x0002, + 0x3236: 0x0002, 0x3237: 0x0002, 0x3238: 0x0002, 0x3239: 0x0002, 0x323a: 0x0002, 0x323b: 0x0002, + 0x323c: 0x0002, 0x323d: 0x0002, 0x323e: 0x0002, 0x323f: 0x0002, + // Block 0xc9, offset 0x3240 + 0x3240: 0x0002, 0x3241: 0x0002, 0x3242: 0x0002, 0x3243: 0x0002, 0x3244: 0x0002, 0x3245: 0x0002, + 0x3246: 0x0002, 0x3247: 0x0002, 0x3248: 0x0002, 0x3249: 0x0002, 0x324a: 0x0002, 0x324b: 0x0002, + 0x324c: 0x0002, 0x324d: 0x0002, 0x324e: 0x0002, 0x324f: 0x0002, 0x3250: 0x0002, 0x3251: 0x0002, + 0x3252: 0x0002, 0x3253: 0x0002, 0x3254: 0x0002, 0x3255: 0x0002, 0x3256: 0x0002, 0x3257: 0x0002, + 0x3258: 0x0002, 0x3259: 0x0002, 0x325a: 0x0002, 0x325b: 0x0002, 0x325c: 0x0002, 0x325d: 0x0002, + 0x325e: 0x0002, 0x325f: 0x0002, 0x3260: 0x0002, 0x3261: 0x0002, 0x3262: 0x0002, 0x3263: 0x0002, + 0x3264: 0x0002, 0x3265: 0x0002, 0x3266: 0x0002, 0x3267: 0x0002, 0x3268: 0x0002, 0x3269: 0x0002, + 0x326a: 0x0002, 0x326b: 0x0002, 0x326c: 0x0002, 0x326d: 0x0002, 0x326e: 0x0002, 0x326f: 0x0002, + 0x3270: 0x0002, 0x3271: 0x0002, 0x3272: 0x0002, 0x3273: 0x0002, 0x3274: 0x0002, 0x3275: 0x0002, + 0x3276: 0x0002, 0x3277: 0x0002, 0x3278: 0x0002, 0x3279: 0x0002, 0x327a: 0x0002, 0x327b: 0x0002, + // Block 0xca, offset 0x3280 + 0x329d: 0x0001, + 0x329e: 0x0001, 0x32a0: 0x0001, 0x32a1: 0x0001, 0x32a2: 0x0001, 0x32a3: 0x0001, + // Block 0xcb, offset 0x32c0 + 0x32c0: 0x0001, 0x32c1: 0x0001, 0x32c2: 0x0001, 0x32c3: 0x0001, 0x32c4: 0x0001, 0x32c5: 0x0001, + 0x32c6: 0x0001, 0x32c7: 0x0001, 0x32c8: 0x0001, 0x32c9: 0x0001, 0x32ca: 0x0001, 0x32cb: 0x0001, + 0x32cc: 0x0001, 0x32cd: 0x0001, 0x32ce: 0x0001, 0x32cf: 0x0001, 0x32d0: 0x0001, 0x32d1: 0x0001, + 0x32d2: 0x0001, 0x32d3: 0x0001, 0x32d4: 0x0001, 0x32d5: 0x0001, 0x32d6: 0x0001, 0x32d7: 0x0001, + 0x32d8: 0x0001, 0x32d9: 0x0001, 0x32da: 0x0001, 0x32db: 0x0001, 0x32dc: 0x0001, 0x32dd: 0x0001, + 0x32de: 0x0001, 0x32df: 0x0001, 0x32e0: 0x0001, 0x32e1: 0x0001, 0x32e2: 0x0001, 0x32e3: 0x0001, + 0x32e4: 0x0001, 0x32e5: 0x0001, 0x32e6: 0x0001, 0x32e7: 0x0001, 0x32e8: 0x0001, 0x32e9: 0x0001, + 0x32ea: 0x0001, 0x32eb: 0x0001, 0x32ec: 0x0001, 0x32ed: 0x0001, + 0x32f0: 0x0001, 0x32f1: 0x0001, 0x32f2: 0x0001, 0x32f3: 0x0001, 0x32f4: 0x0001, 0x32f5: 0x0001, + 0x32f6: 0x0001, 0x32f7: 0x0001, 0x32f8: 0x0001, 0x32f9: 0x0001, 0x32fa: 0x0001, 0x32fb: 0x0001, + 0x32fc: 0x0001, 0x32fd: 0x0001, 0x32fe: 0x0001, 0x32ff: 0x0001, + // Block 0xcc, offset 0x3300 + 0x3300: 0x0001, 0x3301: 0x0001, 0x3302: 0x0001, 0x3303: 0x0001, 0x3304: 0x0001, 0x3305: 0x0001, + 0x3306: 0x0001, + // Block 0xcd, offset 0x3340 + 0x3367: 0x0001, 0x3368: 0x0001, 0x3369: 0x0001, + 0x3373: 0x0001, 0x3374: 0x0001, 0x3375: 0x0001, + 0x3376: 0x0001, 0x3377: 0x0001, 0x3378: 0x0001, 0x3379: 0x0001, 0x337a: 0x0001, 0x337b: 0x0001, + 0x337c: 0x0001, 0x337d: 0x0001, 0x337e: 0x0001, 0x337f: 0x0001, + // Block 0xce, offset 0x3380 + 0x3380: 0x0001, 0x3381: 0x0001, 0x3382: 0x0001, 0x3385: 0x0001, + 0x3386: 0x0001, 0x3387: 0x0001, 0x3388: 0x0001, 0x3389: 0x0001, 0x338a: 0x0001, 0x338b: 0x0001, + 0x33aa: 0x0001, 0x33ab: 0x0001, 0x33ac: 0x0001, 0x33ad: 0x0001, + // Block 0xcf, offset 0x33c0 + 0x33c2: 0x0001, 0x33c3: 0x0001, 0x33c4: 0x0001, + // Block 0xd0, offset 0x3400 + 0x3400: 0x0002, 0x3401: 0x0002, 0x3402: 0x0002, 0x3403: 0x0002, 0x3404: 0x0002, 0x3405: 0x0002, + 0x3406: 0x0002, 0x3407: 0x0002, 0x3408: 0x0002, 0x3409: 0x0002, 0x340a: 0x0002, 0x340b: 0x0002, + 0x340c: 0x0002, 0x340d: 0x0002, 0x340e: 0x0002, 0x340f: 0x0002, 0x3410: 0x0002, 0x3411: 0x0002, + 0x3412: 0x0002, 0x3413: 0x0002, 0x3414: 0x0002, 0x3415: 0x0002, 0x3416: 0x0002, + 0x3420: 0x0002, 0x3421: 0x0002, 0x3422: 0x0002, 0x3423: 0x0002, + 0x3424: 0x0002, 0x3425: 0x0002, 0x3426: 0x0002, 0x3427: 0x0002, 0x3428: 0x0002, 0x3429: 0x0002, + 0x342a: 0x0002, 0x342b: 0x0002, 0x342c: 0x0002, 0x342d: 0x0002, 0x342e: 0x0002, 0x342f: 0x0002, + 0x3430: 0x0002, 0x3431: 0x0002, 0x3432: 0x0002, 0x3433: 0x0002, 0x3434: 0x0002, 0x3435: 0x0002, + 0x3436: 0x0002, + // Block 0xd1, offset 0x3440 + 0x3440: 0x0001, 0x3441: 0x0001, 0x3442: 0x0001, 0x3443: 0x0001, 0x3444: 0x0001, 0x3445: 0x0001, + 0x3446: 0x0001, 0x3447: 0x0001, 0x3448: 0x0001, 0x3449: 0x0001, 0x344a: 0x0001, 0x344b: 0x0001, + 0x344c: 0x0001, 0x344d: 0x0001, 0x344e: 0x0001, 0x344f: 0x0001, 0x3450: 0x0001, 0x3451: 0x0001, + 0x3452: 0x0001, 0x3453: 0x0001, 0x3454: 0x0001, 0x3455: 0x0001, 0x3456: 0x0001, 0x3457: 0x0001, + 0x3458: 0x0001, 0x3459: 0x0001, 0x345a: 0x0001, 0x345b: 0x0001, 0x345c: 0x0001, 0x345d: 0x0001, + 0x345e: 0x0001, 0x345f: 0x0001, 0x3460: 0x0001, 0x3461: 0x0001, 0x3462: 0x0001, 0x3463: 0x0001, + 0x3464: 0x0001, 0x3465: 0x0001, 0x3466: 0x0001, 0x3467: 0x0001, 0x3468: 0x0001, 0x3469: 0x0001, + 0x346a: 0x0001, 0x346b: 0x0001, 0x346c: 0x0001, 0x346d: 0x0001, 0x346e: 0x0001, 0x346f: 0x0001, + 0x3470: 0x0001, 0x3471: 0x0001, 0x3472: 0x0001, 0x3473: 0x0001, 0x3474: 0x0001, 0x3475: 0x0001, + 0x3476: 0x0001, 0x347b: 0x0001, + 0x347c: 0x0001, 0x347d: 0x0001, 0x347e: 0x0001, 0x347f: 0x0001, + // Block 0xd2, offset 0x3480 + 0x3480: 0x0001, 0x3481: 0x0001, 0x3482: 0x0001, 0x3483: 0x0001, 0x3484: 0x0001, 0x3485: 0x0001, + 0x3486: 0x0001, 0x3487: 0x0001, 0x3488: 0x0001, 0x3489: 0x0001, 0x348a: 0x0001, 0x348b: 0x0001, + 0x348c: 0x0001, 0x348d: 0x0001, 0x348e: 0x0001, 0x348f: 0x0001, 0x3490: 0x0001, 0x3491: 0x0001, + 0x3492: 0x0001, 0x3493: 0x0001, 0x3494: 0x0001, 0x3495: 0x0001, 0x3496: 0x0001, 0x3497: 0x0001, + 0x3498: 0x0001, 0x3499: 0x0001, 0x349a: 0x0001, 0x349b: 0x0001, 0x349c: 0x0001, 0x349d: 0x0001, + 0x349e: 0x0001, 0x349f: 0x0001, 0x34a0: 0x0001, 0x34a1: 0x0001, 0x34a2: 0x0001, 0x34a3: 0x0001, + 0x34a4: 0x0001, 0x34a5: 0x0001, 0x34a6: 0x0001, 0x34a7: 0x0001, 0x34a8: 0x0001, 0x34a9: 0x0001, + 0x34aa: 0x0001, 0x34ab: 0x0001, 0x34ac: 0x0001, + 0x34b5: 0x0001, + // Block 0xd3, offset 0x34c0 + 0x34c4: 0x0001, + 0x34db: 0x0001, 0x34dc: 0x0001, 0x34dd: 0x0001, + 0x34de: 0x0001, 0x34df: 0x0001, 0x34e1: 0x0001, 0x34e2: 0x0001, 0x34e3: 0x0001, + 0x34e4: 0x0001, 0x34e5: 0x0001, 0x34e6: 0x0001, 0x34e7: 0x0001, 0x34e8: 0x0001, 0x34e9: 0x0001, + 0x34ea: 0x0001, 0x34eb: 0x0001, 0x34ec: 0x0001, 0x34ed: 0x0001, 0x34ee: 0x0001, 0x34ef: 0x0001, + // Block 0xd4, offset 0x3500 + 0x3500: 0x0001, 0x3501: 0x0001, 0x3502: 0x0001, 0x3503: 0x0001, 0x3504: 0x0001, 0x3505: 0x0001, + 0x3506: 0x0001, 0x3508: 0x0001, 0x3509: 0x0001, 0x350a: 0x0001, 0x350b: 0x0001, + 0x350c: 0x0001, 0x350d: 0x0001, 0x350e: 0x0001, 0x350f: 0x0001, 0x3510: 0x0001, 0x3511: 0x0001, + 0x3512: 0x0001, 0x3513: 0x0001, 0x3514: 0x0001, 0x3515: 0x0001, 0x3516: 0x0001, 0x3517: 0x0001, + 0x3518: 0x0001, 0x351b: 0x0001, 0x351c: 0x0001, 0x351d: 0x0001, + 0x351e: 0x0001, 0x351f: 0x0001, 0x3520: 0x0001, 0x3521: 0x0001, 0x3523: 0x0001, + 0x3524: 0x0001, 0x3526: 0x0001, 0x3527: 0x0001, 0x3528: 0x0001, 0x3529: 0x0001, + 0x352a: 0x0001, + // Block 0xd5, offset 0x3540 + 0x356e: 0x0001, + // Block 0xd6, offset 0x3580 + 0x35ac: 0x0001, 0x35ad: 0x0001, 0x35ae: 0x0001, 0x35af: 0x0001, + // Block 0xd7, offset 0x35c0 + 0x35d0: 0x0001, 0x35d1: 0x0001, + 0x35d2: 0x0001, 0x35d3: 0x0001, 0x35d4: 0x0001, 0x35d5: 0x0001, 0x35d6: 0x0001, + // Block 0xd8, offset 0x3600 + 0x3604: 0x0001, 0x3605: 0x0001, + 0x3606: 0x0001, 0x3607: 0x0001, 0x3608: 0x0001, 0x3609: 0x0001, 0x360a: 0x0001, + // Block 0xd9, offset 0x3640 + 0x3644: 0x0002, + // Block 0xda, offset 0x3680 + 0x368f: 0x0002, + // Block 0xdb, offset 0x36c0 + 0x36c0: 0x0003, 0x36c1: 0x0003, 0x36c2: 0x0003, 0x36c3: 0x0003, 0x36c4: 0x0003, 0x36c5: 0x0003, + 0x36c6: 0x0003, 0x36c7: 0x0003, 0x36c8: 0x0003, 0x36c9: 0x0003, 0x36ca: 0x0003, + 0x36d0: 0x0003, 0x36d1: 0x0003, + 0x36d2: 0x0003, 0x36d3: 0x0003, 0x36d4: 0x0003, 0x36d5: 0x0003, 0x36d6: 0x0003, 0x36d7: 0x0003, + 0x36d8: 0x0003, 0x36d9: 0x0003, 0x36da: 0x0003, 0x36db: 0x0003, 0x36dc: 0x0003, 0x36dd: 0x0003, + 0x36de: 0x0003, 0x36df: 0x0003, 0x36e0: 0x0003, 0x36e1: 0x0003, 0x36e2: 0x0003, 0x36e3: 0x0003, + 0x36e4: 0x0003, 0x36e5: 0x0003, 0x36e6: 0x0003, 0x36e7: 0x0003, 0x36e8: 0x0003, 0x36e9: 0x0003, + 0x36ea: 0x0003, 0x36eb: 0x0003, 0x36ec: 0x0003, 0x36ed: 0x0003, + 0x36f0: 0x0003, 0x36f1: 0x0003, 0x36f2: 0x0003, 0x36f3: 0x0003, 0x36f4: 0x0003, 0x36f5: 0x0003, + 0x36f6: 0x0003, 0x36f7: 0x0003, 0x36f8: 0x0003, 0x36f9: 0x0003, 0x36fa: 0x0003, 0x36fb: 0x0003, + 0x36fc: 0x0003, 0x36fd: 0x0003, 0x36fe: 0x0003, 0x36ff: 0x0003, + // Block 0xdc, offset 0x3700 + 0x3700: 0x0003, 0x3701: 0x0003, 0x3702: 0x0003, 0x3703: 0x0003, 0x3704: 0x0003, 0x3705: 0x0003, + 0x3706: 0x0003, 0x3707: 0x0003, 0x3708: 0x0003, 0x3709: 0x0003, 0x370a: 0x0003, 0x370b: 0x0003, + 0x370c: 0x0003, 0x370d: 0x0003, 0x370e: 0x0003, 0x370f: 0x0003, 0x3710: 0x0003, 0x3711: 0x0003, + 0x3712: 0x0003, 0x3713: 0x0003, 0x3714: 0x0003, 0x3715: 0x0003, 0x3716: 0x0003, 0x3717: 0x0003, + 0x3718: 0x0003, 0x3719: 0x0003, 0x371a: 0x0003, 0x371b: 0x0003, 0x371c: 0x0003, 0x371d: 0x0003, + 0x371e: 0x0003, 0x371f: 0x0003, 0x3720: 0x0003, 0x3721: 0x0003, 0x3722: 0x0003, 0x3723: 0x0003, + 0x3724: 0x0003, 0x3725: 0x0003, 0x3726: 0x0003, 0x3727: 0x0003, 0x3728: 0x0003, 0x3729: 0x0003, + 0x3730: 0x0003, 0x3731: 0x0003, 0x3732: 0x0003, 0x3733: 0x0003, 0x3734: 0x0003, 0x3735: 0x0003, + 0x3736: 0x0003, 0x3737: 0x0003, 0x3738: 0x0003, 0x3739: 0x0003, 0x373a: 0x0003, 0x373b: 0x0003, + 0x373c: 0x0003, 0x373d: 0x0003, 0x373e: 0x0003, 0x373f: 0x0003, + // Block 0xdd, offset 0x3740 + 0x3740: 0x0003, 0x3741: 0x0003, 0x3742: 0x0003, 0x3743: 0x0003, 0x3744: 0x0003, 0x3745: 0x0003, + 0x3746: 0x0003, 0x3747: 0x0003, 0x3748: 0x0003, 0x3749: 0x0003, 0x374a: 0x0003, 0x374b: 0x0003, + 0x374c: 0x0003, 0x374d: 0x0003, 0x374e: 0x0002, 0x374f: 0x0003, 0x3750: 0x0003, 0x3751: 0x0002, + 0x3752: 0x0002, 0x3753: 0x0002, 0x3754: 0x0002, 0x3755: 0x0002, 0x3756: 0x0002, 0x3757: 0x0002, + 0x3758: 0x0002, 0x3759: 0x0002, 0x375a: 0x0002, 0x375b: 0x0003, 0x375c: 0x0003, 0x375d: 0x0003, + 0x375e: 0x0003, 0x375f: 0x0003, 0x3760: 0x0003, 0x3761: 0x0003, 0x3762: 0x0003, 0x3763: 0x0003, + 0x3764: 0x0003, 0x3765: 0x0003, 0x3766: 0x0003, 0x3767: 0x0003, 0x3768: 0x0003, 0x3769: 0x0003, + 0x376a: 0x0003, 0x376b: 0x0003, 0x376c: 0x0003, + // Block 0xde, offset 0x3780 + 0x37a6: 0x0002, 0x37a7: 0x0002, 0x37a8: 0x0002, 0x37a9: 0x0002, + 0x37aa: 0x0002, 0x37ab: 0x0002, 0x37ac: 0x0002, 0x37ad: 0x0002, 0x37ae: 0x0002, 0x37af: 0x0002, + 0x37b0: 0x0002, 0x37b1: 0x0002, 0x37b2: 0x0002, 0x37b3: 0x0002, 0x37b4: 0x0002, 0x37b5: 0x0002, + 0x37b6: 0x0002, 0x37b7: 0x0002, 0x37b8: 0x0002, 0x37b9: 0x0002, 0x37ba: 0x0002, 0x37bb: 0x0002, + 0x37bc: 0x0002, 0x37bd: 0x0002, 0x37be: 0x0002, 0x37bf: 0x0002, + // Block 0xdf, offset 0x37c0 + 0x37c0: 0x0002, 0x37c1: 0x0002, 0x37c2: 0x0002, + 0x37d0: 0x0002, 0x37d1: 0x0002, + 0x37d2: 0x0002, 0x37d3: 0x0002, 0x37d4: 0x0002, 0x37d5: 0x0002, 0x37d6: 0x0002, 0x37d7: 0x0002, + 0x37d8: 0x0002, 0x37d9: 0x0002, 0x37da: 0x0002, 0x37db: 0x0002, 0x37dc: 0x0002, 0x37dd: 0x0002, + 0x37de: 0x0002, 0x37df: 0x0002, 0x37e0: 0x0002, 0x37e1: 0x0002, 0x37e2: 0x0002, 0x37e3: 0x0002, + 0x37e4: 0x0002, 0x37e5: 0x0002, 0x37e6: 0x0002, 0x37e7: 0x0002, 0x37e8: 0x0002, 0x37e9: 0x0002, + 0x37ea: 0x0002, 0x37eb: 0x0002, 0x37ec: 0x0002, 0x37ed: 0x0002, 0x37ee: 0x0002, 0x37ef: 0x0002, + 0x37f0: 0x0002, 0x37f1: 0x0002, 0x37f2: 0x0002, 0x37f3: 0x0002, 0x37f4: 0x0002, 0x37f5: 0x0002, + 0x37f6: 0x0002, 0x37f7: 0x0002, 0x37f8: 0x0002, 0x37f9: 0x0002, 0x37fa: 0x0002, 0x37fb: 0x0002, + // Block 0xe0, offset 0x3800 + 0x3800: 0x0002, 0x3801: 0x0002, 0x3802: 0x0002, 0x3803: 0x0002, 0x3804: 0x0002, 0x3805: 0x0002, + 0x3806: 0x0002, 0x3807: 0x0002, 0x3808: 0x0002, + 0x3810: 0x0002, 0x3811: 0x0002, + 0x3820: 0x0002, 0x3821: 0x0002, 0x3822: 0x0002, 0x3823: 0x0002, + 0x3824: 0x0002, 0x3825: 0x0002, + // Block 0xe1, offset 0x3840 + 0x3840: 0x0002, 0x3841: 0x0002, 0x3842: 0x0002, 0x3843: 0x0002, 0x3844: 0x0002, 0x3845: 0x0002, + 0x3846: 0x0002, 0x3847: 0x0002, 0x3848: 0x0002, 0x3849: 0x0002, 0x384a: 0x0002, 0x384b: 0x0002, + 0x384c: 0x0002, 0x384d: 0x0002, 0x384e: 0x0002, 0x384f: 0x0002, 0x3850: 0x0002, 0x3851: 0x0002, + 0x3852: 0x0002, 0x3853: 0x0002, 0x3854: 0x0002, 0x3855: 0x0002, 0x3856: 0x0002, 0x3857: 0x0002, + 0x3858: 0x0002, 0x3859: 0x0002, 0x385a: 0x0002, 0x385b: 0x0002, 0x385c: 0x0002, 0x385d: 0x0002, + 0x385e: 0x0002, 0x385f: 0x0002, 0x3860: 0x0002, + 0x386d: 0x0002, 0x386e: 0x0002, 0x386f: 0x0002, + 0x3870: 0x0002, 0x3871: 0x0002, 0x3872: 0x0002, 0x3873: 0x0002, 0x3874: 0x0002, 0x3875: 0x0002, + 0x3877: 0x0002, 0x3878: 0x0002, 0x3879: 0x0002, 0x387a: 0x0002, 0x387b: 0x0002, + 0x387c: 0x0002, 0x387d: 0x0002, 0x387e: 0x0002, 0x387f: 0x0002, + // Block 0xe2, offset 0x3880 + 0x3880: 0x0002, 0x3881: 0x0002, 0x3882: 0x0002, 0x3883: 0x0002, 0x3884: 0x0002, 0x3885: 0x0002, + 0x3886: 0x0002, 0x3887: 0x0002, 0x3888: 0x0002, 0x3889: 0x0002, 0x388a: 0x0002, 0x388b: 0x0002, + 0x388c: 0x0002, 0x388d: 0x0002, 0x388e: 0x0002, 0x388f: 0x0002, 0x3890: 0x0002, 0x3891: 0x0002, + 0x3892: 0x0002, 0x3893: 0x0002, 0x3894: 0x0002, 0x3895: 0x0002, 0x3896: 0x0002, 0x3897: 0x0002, + 0x3898: 0x0002, 0x3899: 0x0002, 0x389a: 0x0002, 0x389b: 0x0002, 0x389c: 0x0002, 0x389d: 0x0002, + 0x389e: 0x0002, 0x389f: 0x0002, 0x38a0: 0x0002, 0x38a1: 0x0002, 0x38a2: 0x0002, 0x38a3: 0x0002, + 0x38a4: 0x0002, 0x38a5: 0x0002, 0x38a6: 0x0002, 0x38a7: 0x0002, 0x38a8: 0x0002, 0x38a9: 0x0002, + 0x38aa: 0x0002, 0x38ab: 0x0002, 0x38ac: 0x0002, 0x38ad: 0x0002, 0x38ae: 0x0002, 0x38af: 0x0002, + 0x38b0: 0x0002, 0x38b1: 0x0002, 0x38b2: 0x0002, 0x38b3: 0x0002, 0x38b4: 0x0002, 0x38b5: 0x0002, + 0x38b6: 0x0002, 0x38b7: 0x0002, 0x38b8: 0x0002, 0x38b9: 0x0002, 0x38ba: 0x0002, 0x38bb: 0x0002, + 0x38bc: 0x0002, 0x38be: 0x0002, 0x38bf: 0x0002, + // Block 0xe3, offset 0x38c0 + 0x38c0: 0x0002, 0x38c1: 0x0002, 0x38c2: 0x0002, 0x38c3: 0x0002, 0x38c4: 0x0002, 0x38c5: 0x0002, + 0x38c6: 0x0002, 0x38c7: 0x0002, 0x38c8: 0x0002, 0x38c9: 0x0002, 0x38ca: 0x0002, 0x38cb: 0x0002, + 0x38cc: 0x0002, 0x38cd: 0x0002, 0x38ce: 0x0002, 0x38cf: 0x0002, 0x38d0: 0x0002, 0x38d1: 0x0002, + 0x38d2: 0x0002, 0x38d3: 0x0002, + 0x38e0: 0x0002, 0x38e1: 0x0002, 0x38e2: 0x0002, 0x38e3: 0x0002, + 0x38e4: 0x0002, 0x38e5: 0x0002, 0x38e6: 0x0002, 0x38e7: 0x0002, 0x38e8: 0x0002, 0x38e9: 0x0002, + 0x38ea: 0x0002, 0x38eb: 0x0002, 0x38ec: 0x0002, 0x38ed: 0x0002, 0x38ee: 0x0002, 0x38ef: 0x0002, + 0x38f0: 0x0002, 0x38f1: 0x0002, 0x38f2: 0x0002, 0x38f3: 0x0002, 0x38f4: 0x0002, 0x38f5: 0x0002, + 0x38f6: 0x0002, 0x38f7: 0x0002, 0x38f8: 0x0002, 0x38f9: 0x0002, 0x38fa: 0x0002, 0x38fb: 0x0002, + 0x38fc: 0x0002, 0x38fd: 0x0002, 0x38fe: 0x0002, 0x38ff: 0x0002, + // Block 0xe4, offset 0x3900 + 0x3900: 0x0002, 0x3901: 0x0002, 0x3902: 0x0002, 0x3903: 0x0002, 0x3904: 0x0002, 0x3905: 0x0002, + 0x3906: 0x0002, 0x3907: 0x0002, 0x3908: 0x0002, 0x3909: 0x0002, 0x390a: 0x0002, + 0x390f: 0x0002, 0x3910: 0x0002, 0x3911: 0x0002, + 0x3912: 0x0002, 0x3913: 0x0002, + 0x3920: 0x0002, 0x3921: 0x0002, 0x3922: 0x0002, 0x3923: 0x0002, + 0x3924: 0x0002, 0x3925: 0x0002, 0x3926: 0x0002, 0x3927: 0x0002, 0x3928: 0x0002, 0x3929: 0x0002, + 0x392a: 0x0002, 0x392b: 0x0002, 0x392c: 0x0002, 0x392d: 0x0002, 0x392e: 0x0002, 0x392f: 0x0002, + 0x3930: 0x0002, 0x3934: 0x0002, + 0x3938: 0x0002, 0x3939: 0x0002, 0x393a: 0x0002, 0x393b: 0x0002, + 0x393c: 0x0002, 0x393d: 0x0002, 0x393e: 0x0002, 0x393f: 0x0002, + // Block 0xe5, offset 0x3940 + 0x3940: 0x0002, 0x3941: 0x0002, 0x3942: 0x0002, 0x3943: 0x0002, 0x3944: 0x0002, 0x3945: 0x0002, + 0x3946: 0x0002, 0x3947: 0x0002, 0x3948: 0x0002, 0x3949: 0x0002, 0x394a: 0x0002, 0x394b: 0x0002, + 0x394c: 0x0002, 0x394d: 0x0002, 0x394e: 0x0002, 0x394f: 0x0002, 0x3950: 0x0002, 0x3951: 0x0002, + 0x3952: 0x0002, 0x3953: 0x0002, 0x3954: 0x0002, 0x3955: 0x0002, 0x3956: 0x0002, 0x3957: 0x0002, + 0x3958: 0x0002, 0x3959: 0x0002, 0x395a: 0x0002, 0x395b: 0x0002, 0x395c: 0x0002, 0x395d: 0x0002, + 0x395e: 0x0002, 0x395f: 0x0002, 0x3960: 0x0002, 0x3961: 0x0002, 0x3962: 0x0002, 0x3963: 0x0002, + 0x3964: 0x0002, 0x3965: 0x0002, 0x3966: 0x0002, 0x3967: 0x0002, 0x3968: 0x0002, 0x3969: 0x0002, + 0x396a: 0x0002, 0x396b: 0x0002, 0x396c: 0x0002, 0x396d: 0x0002, 0x396e: 0x0002, 0x396f: 0x0002, + 0x3970: 0x0002, 0x3971: 0x0002, 0x3972: 0x0002, 0x3973: 0x0002, 0x3974: 0x0002, 0x3975: 0x0002, + 0x3976: 0x0002, 0x3977: 0x0002, 0x3978: 0x0002, 0x3979: 0x0002, 0x397a: 0x0002, 0x397b: 0x0002, + 0x397c: 0x0002, 0x397d: 0x0002, 0x397e: 0x0002, + // Block 0xe6, offset 0x3980 + 0x3980: 0x0002, 0x3982: 0x0002, 0x3983: 0x0002, 0x3984: 0x0002, 0x3985: 0x0002, + 0x3986: 0x0002, 0x3987: 0x0002, 0x3988: 0x0002, 0x3989: 0x0002, 0x398a: 0x0002, 0x398b: 0x0002, + 0x398c: 0x0002, 0x398d: 0x0002, 0x398e: 0x0002, 0x398f: 0x0002, 0x3990: 0x0002, 0x3991: 0x0002, + 0x3992: 0x0002, 0x3993: 0x0002, 0x3994: 0x0002, 0x3995: 0x0002, 0x3996: 0x0002, 0x3997: 0x0002, + 0x3998: 0x0002, 0x3999: 0x0002, 0x399a: 0x0002, 0x399b: 0x0002, 0x399c: 0x0002, 0x399d: 0x0002, + 0x399e: 0x0002, 0x399f: 0x0002, 0x39a0: 0x0002, 0x39a1: 0x0002, 0x39a2: 0x0002, 0x39a3: 0x0002, + 0x39a4: 0x0002, 0x39a5: 0x0002, 0x39a6: 0x0002, 0x39a7: 0x0002, 0x39a8: 0x0002, 0x39a9: 0x0002, + 0x39aa: 0x0002, 0x39ab: 0x0002, 0x39ac: 0x0002, 0x39ad: 0x0002, 0x39ae: 0x0002, 0x39af: 0x0002, + 0x39b0: 0x0002, 0x39b1: 0x0002, 0x39b2: 0x0002, 0x39b3: 0x0002, 0x39b4: 0x0002, 0x39b5: 0x0002, + 0x39b6: 0x0002, 0x39b7: 0x0002, 0x39b8: 0x0002, 0x39b9: 0x0002, 0x39ba: 0x0002, 0x39bb: 0x0002, + 0x39bc: 0x0002, 0x39bd: 0x0002, 0x39be: 0x0002, 0x39bf: 0x0002, + // Block 0xe7, offset 0x39c0 + 0x39c0: 0x0002, 0x39c1: 0x0002, 0x39c2: 0x0002, 0x39c3: 0x0002, 0x39c4: 0x0002, 0x39c5: 0x0002, + 0x39c6: 0x0002, 0x39c7: 0x0002, 0x39c8: 0x0002, 0x39c9: 0x0002, 0x39ca: 0x0002, 0x39cb: 0x0002, + 0x39cc: 0x0002, 0x39cd: 0x0002, 0x39ce: 0x0002, 0x39cf: 0x0002, 0x39d0: 0x0002, 0x39d1: 0x0002, + 0x39d2: 0x0002, 0x39d3: 0x0002, 0x39d4: 0x0002, 0x39d5: 0x0002, 0x39d6: 0x0002, 0x39d7: 0x0002, + 0x39d8: 0x0002, 0x39d9: 0x0002, 0x39da: 0x0002, 0x39db: 0x0002, 0x39dc: 0x0002, 0x39dd: 0x0002, + 0x39de: 0x0002, 0x39df: 0x0002, 0x39e0: 0x0002, 0x39e1: 0x0002, 0x39e2: 0x0002, 0x39e3: 0x0002, + 0x39e4: 0x0002, 0x39e5: 0x0002, 0x39e6: 0x0002, 0x39e7: 0x0002, 0x39e8: 0x0002, 0x39e9: 0x0002, + 0x39ea: 0x0002, 0x39eb: 0x0002, 0x39ec: 0x0002, 0x39ed: 0x0002, 0x39ee: 0x0002, 0x39ef: 0x0002, + 0x39f0: 0x0002, 0x39f1: 0x0002, 0x39f2: 0x0002, 0x39f3: 0x0002, 0x39f4: 0x0002, 0x39f5: 0x0002, + 0x39f6: 0x0002, 0x39f7: 0x0002, 0x39f8: 0x0002, 0x39f9: 0x0002, 0x39fa: 0x0002, 0x39fb: 0x0002, + 0x39fc: 0x0002, 0x39ff: 0x0002, + // Block 0xe8, offset 0x3a00 + 0x3a00: 0x0002, 0x3a01: 0x0002, 0x3a02: 0x0002, 0x3a03: 0x0002, 0x3a04: 0x0002, 0x3a05: 0x0002, + 0x3a06: 0x0002, 0x3a07: 0x0002, 0x3a08: 0x0002, 0x3a09: 0x0002, 0x3a0a: 0x0002, 0x3a0b: 0x0002, + 0x3a0c: 0x0002, 0x3a0d: 0x0002, 0x3a0e: 0x0002, 0x3a0f: 0x0002, 0x3a10: 0x0002, 0x3a11: 0x0002, + 0x3a12: 0x0002, 0x3a13: 0x0002, 0x3a14: 0x0002, 0x3a15: 0x0002, 0x3a16: 0x0002, 0x3a17: 0x0002, + 0x3a18: 0x0002, 0x3a19: 0x0002, 0x3a1a: 0x0002, 0x3a1b: 0x0002, 0x3a1c: 0x0002, 0x3a1d: 0x0002, + 0x3a1e: 0x0002, 0x3a1f: 0x0002, 0x3a20: 0x0002, 0x3a21: 0x0002, 0x3a22: 0x0002, 0x3a23: 0x0002, + 0x3a24: 0x0002, 0x3a25: 0x0002, 0x3a26: 0x0002, 0x3a27: 0x0002, 0x3a28: 0x0002, 0x3a29: 0x0002, + 0x3a2a: 0x0002, 0x3a2b: 0x0002, 0x3a2c: 0x0002, 0x3a2d: 0x0002, 0x3a2e: 0x0002, 0x3a2f: 0x0002, + 0x3a30: 0x0002, 0x3a31: 0x0002, 0x3a32: 0x0002, 0x3a33: 0x0002, 0x3a34: 0x0002, 0x3a35: 0x0002, + 0x3a36: 0x0002, 0x3a37: 0x0002, 0x3a38: 0x0002, 0x3a39: 0x0002, 0x3a3a: 0x0002, 0x3a3b: 0x0002, + 0x3a3c: 0x0002, 0x3a3d: 0x0002, + // Block 0xe9, offset 0x3a40 + 0x3a4b: 0x0002, + 0x3a4c: 0x0002, 0x3a4d: 0x0002, 0x3a4e: 0x0002, 0x3a50: 0x0002, 0x3a51: 0x0002, + 0x3a52: 0x0002, 0x3a53: 0x0002, 0x3a54: 0x0002, 0x3a55: 0x0002, 0x3a56: 0x0002, 0x3a57: 0x0002, + 0x3a58: 0x0002, 0x3a59: 0x0002, 0x3a5a: 0x0002, 0x3a5b: 0x0002, 0x3a5c: 0x0002, 0x3a5d: 0x0002, + 0x3a5e: 0x0002, 0x3a5f: 0x0002, 0x3a60: 0x0002, 0x3a61: 0x0002, 0x3a62: 0x0002, 0x3a63: 0x0002, + 0x3a64: 0x0002, 0x3a65: 0x0002, 0x3a66: 0x0002, 0x3a67: 0x0002, + 0x3a7a: 0x0002, + // Block 0xea, offset 0x3a80 + 0x3a95: 0x0002, 0x3a96: 0x0002, + 0x3aa4: 0x0002, + // Block 0xeb, offset 0x3ac0 + 0x3afb: 0x0002, + 0x3afc: 0x0002, 0x3afd: 0x0002, 0x3afe: 0x0002, 0x3aff: 0x0002, + // Block 0xec, offset 0x3b00 + 0x3b00: 0x0002, 0x3b01: 0x0002, 0x3b02: 0x0002, 0x3b03: 0x0002, 0x3b04: 0x0002, 0x3b05: 0x0002, + 0x3b06: 0x0002, 0x3b07: 0x0002, 0x3b08: 0x0002, 0x3b09: 0x0002, 0x3b0a: 0x0002, 0x3b0b: 0x0002, + 0x3b0c: 0x0002, 0x3b0d: 0x0002, 0x3b0e: 0x0002, 0x3b0f: 0x0002, + // Block 0xed, offset 0x3b40 + 0x3b40: 0x0002, 0x3b41: 0x0002, 0x3b42: 0x0002, 0x3b43: 0x0002, 0x3b44: 0x0002, 0x3b45: 0x0002, + 0x3b4c: 0x0002, 0x3b50: 0x0002, 0x3b51: 0x0002, + 0x3b52: 0x0002, 0x3b55: 0x0002, 0x3b56: 0x0002, 0x3b57: 0x0002, + 0x3b58: 0x0002, 0x3b5c: 0x0002, 0x3b5d: 0x0002, + 0x3b5e: 0x0002, 0x3b5f: 0x0002, + 0x3b6b: 0x0002, 0x3b6c: 0x0002, + 0x3b74: 0x0002, 0x3b75: 0x0002, + 0x3b76: 0x0002, 0x3b77: 0x0002, 0x3b78: 0x0002, 0x3b79: 0x0002, 0x3b7a: 0x0002, 0x3b7b: 0x0002, + 0x3b7c: 0x0002, + // Block 0xee, offset 0x3b80 + 0x3ba0: 0x0002, 0x3ba1: 0x0002, 0x3ba2: 0x0002, 0x3ba3: 0x0002, + 0x3ba4: 0x0002, 0x3ba5: 0x0002, 0x3ba6: 0x0002, 0x3ba7: 0x0002, 0x3ba8: 0x0002, 0x3ba9: 0x0002, + 0x3baa: 0x0002, 0x3bab: 0x0002, + 0x3bb0: 0x0002, + // Block 0xef, offset 0x3bc0 + 0x3bcc: 0x0002, 0x3bcd: 0x0002, 0x3bce: 0x0002, 0x3bcf: 0x0002, 0x3bd0: 0x0002, 0x3bd1: 0x0002, + 0x3bd2: 0x0002, 0x3bd3: 0x0002, 0x3bd4: 0x0002, 0x3bd5: 0x0002, 0x3bd6: 0x0002, 0x3bd7: 0x0002, + 0x3bd8: 0x0002, 0x3bd9: 0x0002, 0x3bda: 0x0002, 0x3bdb: 0x0002, 0x3bdc: 0x0002, 0x3bdd: 0x0002, + 0x3bde: 0x0002, 0x3bdf: 0x0002, 0x3be0: 0x0002, 0x3be1: 0x0002, 0x3be2: 0x0002, 0x3be3: 0x0002, + 0x3be4: 0x0002, 0x3be5: 0x0002, 0x3be6: 0x0002, 0x3be7: 0x0002, 0x3be8: 0x0002, 0x3be9: 0x0002, + 0x3bea: 0x0002, 0x3beb: 0x0002, 0x3bec: 0x0002, 0x3bed: 0x0002, 0x3bee: 0x0002, 0x3bef: 0x0002, + 0x3bf0: 0x0002, 0x3bf1: 0x0002, 0x3bf2: 0x0002, 0x3bf3: 0x0002, 0x3bf4: 0x0002, 0x3bf5: 0x0002, + 0x3bf6: 0x0002, 0x3bf7: 0x0002, 0x3bf8: 0x0002, 0x3bf9: 0x0002, 0x3bfa: 0x0002, + 0x3bfc: 0x0002, 0x3bfd: 0x0002, 0x3bfe: 0x0002, 0x3bff: 0x0002, + // Block 0xf0, offset 0x3c00 + 0x3c00: 0x0002, 0x3c01: 0x0002, 0x3c02: 0x0002, 0x3c03: 0x0002, 0x3c04: 0x0002, 0x3c05: 0x0002, + 0x3c07: 0x0002, 0x3c08: 0x0002, 0x3c09: 0x0002, 0x3c0a: 0x0002, 0x3c0b: 0x0002, + 0x3c0c: 0x0002, 0x3c0d: 0x0002, 0x3c0e: 0x0002, 0x3c0f: 0x0002, 0x3c10: 0x0002, 0x3c11: 0x0002, + 0x3c12: 0x0002, 0x3c13: 0x0002, 0x3c14: 0x0002, 0x3c15: 0x0002, 0x3c16: 0x0002, 0x3c17: 0x0002, + 0x3c18: 0x0002, 0x3c19: 0x0002, 0x3c1a: 0x0002, 0x3c1b: 0x0002, 0x3c1c: 0x0002, 0x3c1d: 0x0002, + 0x3c1e: 0x0002, 0x3c1f: 0x0002, 0x3c20: 0x0002, 0x3c21: 0x0002, 0x3c22: 0x0002, 0x3c23: 0x0002, + 0x3c24: 0x0002, 0x3c25: 0x0002, 0x3c26: 0x0002, 0x3c27: 0x0002, 0x3c28: 0x0002, 0x3c29: 0x0002, + 0x3c2a: 0x0002, 0x3c2b: 0x0002, 0x3c2c: 0x0002, 0x3c2d: 0x0002, 0x3c2e: 0x0002, 0x3c2f: 0x0002, + 0x3c30: 0x0002, 0x3c31: 0x0002, 0x3c32: 0x0002, 0x3c33: 0x0002, 0x3c34: 0x0002, 0x3c35: 0x0002, + 0x3c36: 0x0002, 0x3c37: 0x0002, 0x3c38: 0x0002, 0x3c39: 0x0002, 0x3c3a: 0x0002, 0x3c3b: 0x0002, + 0x3c3c: 0x0002, 0x3c3d: 0x0002, 0x3c3e: 0x0002, 0x3c3f: 0x0002, + // Block 0xf1, offset 0x3c40 + 0x3c70: 0x0002, 0x3c71: 0x0002, 0x3c72: 0x0002, 0x3c73: 0x0002, 0x3c74: 0x0002, 0x3c75: 0x0002, + 0x3c76: 0x0002, 0x3c77: 0x0002, 0x3c78: 0x0002, 0x3c79: 0x0002, 0x3c7a: 0x0002, 0x3c7b: 0x0002, + 0x3c7c: 0x0002, + // Block 0xf2, offset 0x3c80 + 0x3c80: 0x0002, 0x3c81: 0x0002, 0x3c82: 0x0002, 0x3c83: 0x0002, 0x3c84: 0x0002, 0x3c85: 0x0002, + 0x3c86: 0x0002, 0x3c87: 0x0002, 0x3c88: 0x0002, 0x3c89: 0x0002, 0x3c8a: 0x0002, + 0x3c8e: 0x0002, 0x3c8f: 0x0002, 0x3c90: 0x0002, 0x3c91: 0x0002, + 0x3c92: 0x0002, 0x3c93: 0x0002, 0x3c94: 0x0002, 0x3c95: 0x0002, 0x3c96: 0x0002, 0x3c97: 0x0002, + 0x3c98: 0x0002, 0x3c99: 0x0002, 0x3c9a: 0x0002, 0x3c9b: 0x0002, 0x3c9c: 0x0002, 0x3c9d: 0x0002, + 0x3c9e: 0x0002, 0x3c9f: 0x0002, 0x3ca0: 0x0002, 0x3ca1: 0x0002, 0x3ca2: 0x0002, 0x3ca3: 0x0002, + 0x3ca4: 0x0002, 0x3ca5: 0x0002, 0x3ca6: 0x0002, 0x3ca7: 0x0002, 0x3ca8: 0x0002, 0x3ca9: 0x0002, + 0x3caa: 0x0002, 0x3cab: 0x0002, 0x3cac: 0x0002, 0x3cad: 0x0002, 0x3cae: 0x0002, 0x3caf: 0x0002, + 0x3cb0: 0x0002, 0x3cb1: 0x0002, 0x3cb2: 0x0002, 0x3cb3: 0x0002, 0x3cb4: 0x0002, 0x3cb5: 0x0002, + 0x3cb6: 0x0002, 0x3cb7: 0x0002, 0x3cb8: 0x0002, 0x3cb9: 0x0002, 0x3cba: 0x0002, 0x3cbb: 0x0002, + 0x3cbc: 0x0002, 0x3cbd: 0x0002, 0x3cbe: 0x0002, 0x3cbf: 0x0002, + // Block 0xf3, offset 0x3cc0 + 0x3cc0: 0x0002, 0x3cc1: 0x0002, 0x3cc2: 0x0002, 0x3cc3: 0x0002, 0x3cc4: 0x0002, 0x3cc5: 0x0002, + 0x3cc6: 0x0002, 0x3cc8: 0x0002, + 0x3ccd: 0x0002, 0x3cce: 0x0002, 0x3ccf: 0x0002, 0x3cd0: 0x0002, 0x3cd1: 0x0002, + 0x3cd2: 0x0002, 0x3cd3: 0x0002, 0x3cd4: 0x0002, 0x3cd5: 0x0002, 0x3cd6: 0x0002, 0x3cd7: 0x0002, + 0x3cd8: 0x0002, 0x3cd9: 0x0002, 0x3cda: 0x0002, 0x3cdb: 0x0002, 0x3cdc: 0x0002, + 0x3cdf: 0x0002, 0x3ce0: 0x0002, 0x3ce1: 0x0002, 0x3ce2: 0x0002, 0x3ce3: 0x0002, + 0x3ce4: 0x0002, 0x3ce5: 0x0002, 0x3ce6: 0x0002, 0x3ce7: 0x0002, 0x3ce8: 0x0002, 0x3ce9: 0x0002, + 0x3cea: 0x0002, 0x3cef: 0x0002, + 0x3cf0: 0x0002, 0x3cf1: 0x0002, 0x3cf2: 0x0002, 0x3cf3: 0x0002, 0x3cf4: 0x0002, 0x3cf5: 0x0002, + 0x3cf6: 0x0002, 0x3cf7: 0x0002, 0x3cf8: 0x0002, + // Block 0xf4, offset 0x3d00 + 0x3d01: 0x0001, + 0x3d20: 0x0001, 0x3d21: 0x0001, 0x3d22: 0x0001, 0x3d23: 0x0001, + 0x3d24: 0x0001, 0x3d25: 0x0001, 0x3d26: 0x0001, 0x3d27: 0x0001, 0x3d28: 0x0001, 0x3d29: 0x0001, + 0x3d2a: 0x0001, 0x3d2b: 0x0001, 0x3d2c: 0x0001, 0x3d2d: 0x0001, 0x3d2e: 0x0001, 0x3d2f: 0x0001, + 0x3d30: 0x0001, 0x3d31: 0x0001, 0x3d32: 0x0001, 0x3d33: 0x0001, 0x3d34: 0x0001, 0x3d35: 0x0001, + 0x3d36: 0x0001, 0x3d37: 0x0001, 0x3d38: 0x0001, 0x3d39: 0x0001, 0x3d3a: 0x0001, 0x3d3b: 0x0001, + 0x3d3c: 0x0001, 0x3d3d: 0x0001, 0x3d3e: 0x0001, 0x3d3f: 0x0001, + // Block 0xf5, offset 0x3d40 + 0x3d40: 0x0003, 0x3d41: 0x0003, 0x3d42: 0x0003, 0x3d43: 0x0003, 0x3d44: 0x0003, 0x3d45: 0x0003, + 0x3d46: 0x0003, 0x3d47: 0x0003, 0x3d48: 0x0003, 0x3d49: 0x0003, 0x3d4a: 0x0003, 0x3d4b: 0x0003, + 0x3d4c: 0x0003, 0x3d4d: 0x0003, 0x3d4e: 0x0003, 0x3d4f: 0x0003, 0x3d50: 0x0003, 0x3d51: 0x0003, + 0x3d52: 0x0003, 0x3d53: 0x0003, 0x3d54: 0x0003, 0x3d55: 0x0003, 0x3d56: 0x0003, 0x3d57: 0x0003, + 0x3d58: 0x0003, 0x3d59: 0x0003, 0x3d5a: 0x0003, 0x3d5b: 0x0003, 0x3d5c: 0x0003, 0x3d5d: 0x0003, + 0x3d5e: 0x0003, 0x3d5f: 0x0003, 0x3d60: 0x0003, 0x3d61: 0x0003, 0x3d62: 0x0003, 0x3d63: 0x0003, + 0x3d64: 0x0003, 0x3d65: 0x0003, 0x3d66: 0x0003, 0x3d67: 0x0003, 0x3d68: 0x0003, 0x3d69: 0x0003, + 0x3d6a: 0x0003, 0x3d6b: 0x0003, 0x3d6c: 0x0003, 0x3d6d: 0x0003, 0x3d6e: 0x0003, 0x3d6f: 0x0003, + 0x3d70: 0x0003, 0x3d71: 0x0003, 0x3d72: 0x0003, 0x3d73: 0x0003, 0x3d74: 0x0003, 0x3d75: 0x0003, + 0x3d76: 0x0003, 0x3d77: 0x0003, 0x3d78: 0x0003, 0x3d79: 0x0003, 0x3d7a: 0x0003, 0x3d7b: 0x0003, + 0x3d7c: 0x0003, 0x3d7d: 0x0003, +} + +// stringWidthIndex: 30 blocks, 1920 entries, 1920 bytes +// Block 0 is the zero block. +var stringWidthIndex = [1920]uint8{ + // Block 0x0, offset 0x0 + // Block 0x1, offset 0x40 + // Block 0x2, offset 0x80 + // Block 0x3, offset 0xc0 + 0xc2: 0x01, 0xc3: 0x02, 0xc4: 0x03, 0xc5: 0x04, 0xc7: 0x05, + 0xc9: 0x06, 0xcb: 0x07, 0xcc: 0x08, 0xcd: 0x09, 0xce: 0x0a, 0xcf: 0x0b, + 0xd0: 0x0c, 0xd1: 0x0d, 0xd2: 0x0e, 0xd6: 0x0f, 0xd7: 0x10, + 0xd8: 0x11, 0xd9: 0x12, 0xdb: 0x13, 0xdc: 0x14, 0xdd: 0x15, 0xde: 0x16, 0xdf: 0x17, + 0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe5: 0x06, 0xe6: 0x06, 0xe7: 0x06, + 0xe8: 0x06, 0xe9: 0x06, 0xea: 0x07, 0xeb: 0x06, 0xec: 0x06, 0xed: 0x08, 0xee: 0x09, 0xef: 0x0a, + 0xf0: 0x17, 0xf3: 0x1a, 0xf4: 0x1b, + // Block 0x4, offset 0x100 + 0x120: 0x18, 0x121: 0x19, 0x122: 0x1a, 0x123: 0x1b, 0x124: 0x1c, 0x125: 0x1d, 0x126: 0x1e, 0x127: 0x1f, + 0x128: 0x20, 0x129: 0x21, 0x12a: 0x20, 0x12b: 0x22, 0x12c: 0x23, 0x12d: 0x24, 0x12e: 0x25, 0x12f: 0x26, + 0x130: 0x27, 0x131: 0x28, 0x132: 0x23, 0x133: 0x29, 0x134: 0x2a, 0x135: 0x2b, 0x136: 0x2c, 0x137: 0x2d, + 0x138: 0x2e, 0x139: 0x2f, 0x13a: 0x30, 0x13b: 0x31, 0x13c: 0x32, 0x13d: 0x33, 0x13e: 0x34, 0x13f: 0x35, + // Block 0x5, offset 0x140 + 0x140: 0x36, 0x141: 0x37, 0x142: 0x38, 0x144: 0x39, 0x145: 0x3a, + 0x14d: 0x3b, + 0x15c: 0x3c, 0x15d: 0x3d, 0x15e: 0x3e, 0x15f: 0x3f, + 0x160: 0x40, 0x162: 0x41, 0x164: 0x42, + 0x168: 0x43, 0x169: 0x44, 0x16a: 0x45, 0x16b: 0x46, 0x16c: 0x47, 0x16d: 0x48, 0x16e: 0x49, 0x16f: 0x4a, + 0x170: 0x4b, 0x173: 0x4c, 0x177: 0x08, + // Block 0x6, offset 0x180 + 0x180: 0x4d, 0x181: 0x4e, 0x182: 0x4f, 0x183: 0x50, 0x184: 0x51, 0x185: 0x52, 0x186: 0x53, 0x187: 0x54, + 0x188: 0x55, 0x189: 0x56, 0x18a: 0x57, 0x18c: 0x58, 0x18f: 0x59, + 0x191: 0x5a, 0x192: 0x5b, 0x193: 0x5c, 0x194: 0x5b, 0x195: 0x5d, 0x196: 0x5e, 0x197: 0x5f, + 0x198: 0x60, 0x199: 0x61, 0x19a: 0x62, 0x19b: 0x63, 0x19c: 0x64, 0x19d: 0x65, 0x19e: 0x66, + 0x1ac: 0x67, 0x1ad: 0x68, + 0x1b3: 0x69, 0x1b5: 0x6a, 0x1b7: 0x6b, + 0x1ba: 0x6c, 0x1bb: 0x6d, 0x1bc: 0x39, 0x1bd: 0x39, 0x1be: 0x39, 0x1bf: 0x6e, + // Block 0x7, offset 0x1c0 + 0x1c0: 0x6f, 0x1c1: 0x70, 0x1c2: 0x71, 0x1c3: 0x39, 0x1c4: 0x72, 0x1c5: 0x39, 0x1c6: 0x73, 0x1c7: 0x74, + 0x1c8: 0x75, 0x1c9: 0x76, 0x1ca: 0x39, 0x1cb: 0x39, 0x1cc: 0x39, 0x1cd: 0x39, 0x1ce: 0x39, 0x1cf: 0x39, + 0x1d0: 0x39, 0x1d1: 0x39, 0x1d2: 0x39, 0x1d3: 0x39, 0x1d4: 0x39, 0x1d5: 0x39, 0x1d6: 0x39, 0x1d7: 0x39, + 0x1d8: 0x39, 0x1d9: 0x39, 0x1da: 0x39, 0x1db: 0x39, 0x1dc: 0x39, 0x1dd: 0x39, 0x1de: 0x39, 0x1df: 0x39, + 0x1e0: 0x39, 0x1e1: 0x39, 0x1e2: 0x39, 0x1e3: 0x39, 0x1e4: 0x39, 0x1e5: 0x39, 0x1e6: 0x39, 0x1e7: 0x39, + 0x1e8: 0x39, 0x1e9: 0x39, 0x1ea: 0x39, 0x1eb: 0x39, 0x1ec: 0x39, 0x1ed: 0x39, 0x1ee: 0x39, 0x1ef: 0x39, + 0x1f0: 0x39, 0x1f1: 0x39, 0x1f2: 0x39, 0x1f3: 0x39, 0x1f4: 0x39, 0x1f5: 0x39, 0x1f6: 0x39, 0x1f7: 0x39, + 0x1f8: 0x39, 0x1f9: 0x39, 0x1fa: 0x39, 0x1fb: 0x39, 0x1fc: 0x39, 0x1fd: 0x39, 0x1fe: 0x39, 0x1ff: 0x39, + // Block 0x8, offset 0x200 + 0x200: 0x39, 0x201: 0x39, 0x202: 0x39, 0x203: 0x39, 0x204: 0x39, 0x205: 0x39, 0x206: 0x39, 0x207: 0x39, + 0x208: 0x39, 0x209: 0x39, 0x20a: 0x39, 0x20b: 0x39, 0x20c: 0x39, 0x20d: 0x39, 0x20e: 0x39, 0x20f: 0x39, + 0x210: 0x39, 0x211: 0x39, 0x212: 0x39, 0x213: 0x39, 0x214: 0x39, 0x215: 0x39, 0x216: 0x39, 0x217: 0x39, + 0x218: 0x39, 0x219: 0x39, 0x21a: 0x39, 0x21b: 0x39, 0x21c: 0x39, 0x21d: 0x39, 0x21e: 0x39, 0x21f: 0x39, + 0x220: 0x39, 0x221: 0x39, 0x222: 0x39, 0x223: 0x39, 0x224: 0x39, 0x225: 0x39, 0x226: 0x39, 0x227: 0x39, + 0x228: 0x39, 0x229: 0x39, 0x22a: 0x39, 0x22b: 0x39, 0x22c: 0x39, 0x22d: 0x39, 0x22e: 0x39, 0x22f: 0x39, + 0x230: 0x39, 0x231: 0x39, 0x232: 0x39, 0x233: 0x39, 0x234: 0x39, 0x235: 0x39, 0x236: 0x39, 0x237: 0x39, + 0x238: 0x39, 0x239: 0x39, 0x23a: 0x39, 0x23b: 0x39, 0x23c: 0x39, 0x23d: 0x39, 0x23e: 0x39, 0x23f: 0x39, + // Block 0x9, offset 0x240 + 0x240: 0x39, 0x241: 0x39, 0x242: 0x39, 0x243: 0x39, 0x244: 0x39, 0x245: 0x39, 0x246: 0x39, 0x247: 0x39, + 0x248: 0x39, 0x249: 0x39, 0x24a: 0x39, 0x24b: 0x39, 0x24c: 0x39, 0x24d: 0x39, 0x24e: 0x39, 0x24f: 0x39, + 0x250: 0x39, 0x251: 0x39, 0x252: 0x77, 0x253: 0x78, + 0x259: 0x79, 0x25a: 0x7a, 0x25b: 0x7b, + 0x260: 0x7c, 0x263: 0x7d, 0x264: 0x7e, 0x265: 0x7f, 0x266: 0x80, 0x267: 0x81, + 0x268: 0x82, 0x269: 0x83, 0x26a: 0x84, 0x26b: 0x85, 0x26f: 0x86, + 0x270: 0x39, 0x271: 0x39, 0x272: 0x39, 0x273: 0x39, 0x274: 0x39, 0x275: 0x39, 0x276: 0x39, 0x277: 0x39, + 0x278: 0x39, 0x279: 0x39, 0x27a: 0x39, 0x27b: 0x39, 0x27c: 0x39, 0x27d: 0x39, 0x27e: 0x39, 0x27f: 0x39, + // Block 0xa, offset 0x280 + 0x280: 0x39, 0x281: 0x39, 0x282: 0x39, 0x283: 0x39, 0x284: 0x39, 0x285: 0x39, 0x286: 0x39, 0x287: 0x39, + 0x288: 0x39, 0x289: 0x39, 0x28a: 0x39, 0x28b: 0x39, 0x28c: 0x39, 0x28d: 0x39, 0x28e: 0x39, 0x28f: 0x39, + 0x290: 0x39, 0x291: 0x39, 0x292: 0x39, 0x293: 0x39, 0x294: 0x39, 0x295: 0x39, 0x296: 0x39, 0x297: 0x39, + 0x298: 0x39, 0x299: 0x39, 0x29a: 0x39, 0x29b: 0x39, 0x29c: 0x39, 0x29d: 0x39, 0x29e: 0x87, + // Block 0xb, offset 0x2c0 + 0x2c0: 0x5b, 0x2c1: 0x5b, 0x2c2: 0x5b, 0x2c3: 0x5b, 0x2c4: 0x5b, 0x2c5: 0x5b, 0x2c6: 0x5b, 0x2c7: 0x5b, + 0x2c8: 0x5b, 0x2c9: 0x5b, 0x2ca: 0x5b, 0x2cb: 0x5b, 0x2cc: 0x5b, 0x2cd: 0x5b, 0x2ce: 0x5b, 0x2cf: 0x5b, + 0x2d0: 0x5b, 0x2d1: 0x5b, 0x2d2: 0x5b, 0x2d3: 0x5b, 0x2d4: 0x5b, 0x2d5: 0x5b, 0x2d6: 0x5b, 0x2d7: 0x5b, + 0x2d8: 0x5b, 0x2d9: 0x5b, 0x2da: 0x5b, 0x2db: 0x5b, 0x2dc: 0x5b, 0x2dd: 0x5b, 0x2de: 0x5b, 0x2df: 0x5b, + 0x2e0: 0x5b, 0x2e1: 0x5b, 0x2e2: 0x5b, 0x2e3: 0x5b, 0x2e4: 0x5b, 0x2e5: 0x5b, 0x2e6: 0x5b, 0x2e7: 0x5b, + 0x2e8: 0x5b, 0x2e9: 0x5b, 0x2ea: 0x5b, 0x2eb: 0x5b, 0x2ec: 0x5b, 0x2ed: 0x5b, 0x2ee: 0x5b, 0x2ef: 0x5b, + 0x2f0: 0x5b, 0x2f1: 0x5b, 0x2f2: 0x5b, 0x2f3: 0x5b, 0x2f4: 0x5b, 0x2f5: 0x5b, 0x2f6: 0x5b, 0x2f7: 0x5b, + 0x2f8: 0x5b, 0x2f9: 0x5b, 0x2fa: 0x5b, 0x2fb: 0x5b, 0x2fc: 0x5b, 0x2fd: 0x5b, 0x2fe: 0x5b, 0x2ff: 0x5b, + // Block 0xc, offset 0x300 + 0x300: 0x5b, 0x301: 0x5b, 0x302: 0x5b, 0x303: 0x5b, 0x304: 0x5b, 0x305: 0x5b, 0x306: 0x5b, 0x307: 0x5b, + 0x308: 0x5b, 0x309: 0x5b, 0x30a: 0x5b, 0x30b: 0x5b, 0x30c: 0x5b, 0x30d: 0x5b, 0x30e: 0x5b, 0x30f: 0x5b, + 0x310: 0x5b, 0x311: 0x5b, 0x312: 0x5b, 0x313: 0x5b, 0x314: 0x5b, 0x315: 0x5b, 0x316: 0x5b, 0x317: 0x5b, + 0x318: 0x5b, 0x319: 0x5b, 0x31a: 0x5b, 0x31b: 0x5b, 0x31c: 0x5b, 0x31d: 0x5b, 0x31e: 0x5b, 0x31f: 0x5b, + 0x320: 0x5b, 0x321: 0x5b, 0x322: 0x5b, 0x323: 0x5b, 0x324: 0x39, 0x325: 0x39, 0x326: 0x39, 0x327: 0x39, + 0x328: 0x39, 0x329: 0x39, 0x32a: 0x39, 0x32b: 0x39, 0x32c: 0x88, + 0x338: 0x89, 0x339: 0x8a, 0x33b: 0x6a, 0x33c: 0x70, 0x33d: 0x8b, 0x33f: 0x8c, + // Block 0xd, offset 0x340 + 0x347: 0x8d, + 0x34b: 0x8e, 0x34d: 0x8f, + 0x368: 0x90, 0x36b: 0x91, + 0x374: 0x92, + 0x37a: 0x93, 0x37b: 0x94, 0x37d: 0x95, 0x37e: 0x96, + // Block 0xe, offset 0x380 + 0x380: 0x97, 0x381: 0x98, 0x382: 0x99, 0x383: 0x9a, 0x384: 0x9b, 0x385: 0x9c, 0x386: 0x9d, 0x387: 0x9e, + 0x388: 0x9f, 0x389: 0x2c, 0x38b: 0xa0, 0x38c: 0x2a, 0x38d: 0xa1, + 0x390: 0xa2, 0x391: 0xa3, 0x392: 0xa4, 0x393: 0xa5, 0x396: 0xa6, 0x397: 0xa7, + 0x398: 0xa8, 0x399: 0xa9, 0x39a: 0xaa, 0x39c: 0xab, + 0x3a0: 0xac, 0x3a4: 0xad, 0x3a5: 0xae, 0x3a7: 0xaf, + 0x3a8: 0xb0, 0x3a9: 0xb1, 0x3aa: 0xb2, + 0x3b0: 0xb3, 0x3b2: 0xb4, 0x3b4: 0xb5, 0x3b5: 0xb6, 0x3b6: 0xb7, + 0x3bb: 0xb8, 0x3bc: 0xb9, 0x3bd: 0xba, + // Block 0xf, offset 0x3c0 + 0x3d0: 0x45, 0x3d1: 0xbb, + // Block 0x10, offset 0x400 + 0x42b: 0xbc, 0x42c: 0xbd, + 0x43d: 0xbe, 0x43e: 0xbf, 0x43f: 0xc0, + // Block 0x11, offset 0x440 + 0x440: 0x39, 0x441: 0x39, 0x442: 0x39, 0x443: 0x39, 0x444: 0x39, 0x445: 0x39, 0x446: 0x39, 0x447: 0x39, + 0x448: 0x39, 0x449: 0x39, 0x44a: 0x39, 0x44b: 0x39, 0x44c: 0x39, 0x44d: 0x39, 0x44e: 0x39, 0x44f: 0x39, + 0x450: 0x39, 0x451: 0x39, 0x452: 0x39, 0x453: 0x39, 0x454: 0x39, 0x455: 0x39, 0x456: 0x39, 0x457: 0x39, + 0x458: 0x39, 0x459: 0x39, 0x45a: 0x39, 0x45b: 0x39, 0x45c: 0x39, 0x45d: 0x39, 0x45e: 0x39, 0x45f: 0x39, + 0x460: 0x39, 0x461: 0x39, 0x462: 0x39, 0x463: 0x39, 0x464: 0x39, 0x465: 0x39, 0x466: 0x39, 0x467: 0x39, + 0x468: 0x39, 0x469: 0x39, 0x46a: 0x39, 0x46b: 0x39, 0x46c: 0x39, 0x46d: 0x39, 0x46e: 0x39, 0x46f: 0x39, + 0x470: 0x39, 0x471: 0x39, 0x472: 0x39, 0x473: 0xc1, 0x474: 0xc2, 0x476: 0x39, 0x477: 0xc3, + // Block 0x12, offset 0x480 + 0x4bf: 0xc4, + // Block 0x13, offset 0x4c0 + 0x4c0: 0x39, 0x4c1: 0x39, 0x4c2: 0x39, 0x4c3: 0x39, 0x4c4: 0xc5, 0x4c5: 0xc6, 0x4c6: 0x39, 0x4c7: 0x39, + 0x4c8: 0x39, 0x4c9: 0x39, 0x4ca: 0x39, 0x4cb: 0xc7, + 0x4f2: 0xc8, + // Block 0x14, offset 0x500 + 0x53c: 0xc9, 0x53d: 0xca, + // Block 0x15, offset 0x540 + 0x545: 0xcb, 0x546: 0xcc, + 0x549: 0xcd, 0x54c: 0x39, 0x54d: 0xce, + 0x568: 0xcf, 0x569: 0xd0, 0x56a: 0xd1, + // Block 0x16, offset 0x580 + 0x580: 0xd2, 0x582: 0xbe, 0x584: 0xbd, + 0x58a: 0xd3, 0x58b: 0xd4, + 0x593: 0xd4, + 0x5a3: 0xd5, 0x5a5: 0xd6, + // Block 0x17, offset 0x5c0 + 0x5c0: 0xd7, 0x5c3: 0xd8, 0x5c4: 0xd9, 0x5c5: 0xda, 0x5c6: 0xdb, 0x5c7: 0xdc, + 0x5c8: 0xdd, 0x5c9: 0xde, 0x5cc: 0xdf, 0x5cd: 0xe0, 0x5ce: 0xe1, 0x5cf: 0xe2, + 0x5d0: 0xe3, 0x5d1: 0xe4, 0x5d2: 0x39, 0x5d3: 0xe5, 0x5d4: 0xe6, 0x5d5: 0xe7, 0x5d6: 0xe8, 0x5d7: 0xe9, + 0x5d8: 0x39, 0x5d9: 0xea, 0x5da: 0x39, 0x5db: 0xeb, 0x5df: 0xec, + 0x5e4: 0xed, 0x5e5: 0xee, 0x5e6: 0x39, 0x5e7: 0x39, + 0x5e9: 0xef, 0x5ea: 0xf0, 0x5eb: 0xf1, + // Block 0x18, offset 0x600 + 0x600: 0x39, 0x601: 0x39, 0x602: 0x39, 0x603: 0x39, 0x604: 0x39, 0x605: 0x39, 0x606: 0x39, 0x607: 0x39, + 0x608: 0x39, 0x609: 0x39, 0x60a: 0x39, 0x60b: 0x39, 0x60c: 0x39, 0x60d: 0x39, 0x60e: 0x39, 0x60f: 0x39, + 0x610: 0x39, 0x611: 0x39, 0x612: 0x39, 0x613: 0x39, 0x614: 0x39, 0x615: 0x39, 0x616: 0x39, 0x617: 0x39, + 0x618: 0x39, 0x619: 0x39, 0x61a: 0x39, 0x61b: 0x39, 0x61c: 0x39, 0x61d: 0x39, 0x61e: 0x39, 0x61f: 0x39, + 0x620: 0x39, 0x621: 0x39, 0x622: 0x39, 0x623: 0x39, 0x624: 0x39, 0x625: 0x39, 0x626: 0x39, 0x627: 0x39, + 0x628: 0x39, 0x629: 0x39, 0x62a: 0x39, 0x62b: 0x39, 0x62c: 0x39, 0x62d: 0x39, 0x62e: 0x39, 0x62f: 0x39, + 0x630: 0x39, 0x631: 0x39, 0x632: 0x39, 0x633: 0x39, 0x634: 0x39, 0x635: 0x39, 0x636: 0x39, 0x637: 0x39, + 0x638: 0x39, 0x639: 0x39, 0x63a: 0x39, 0x63b: 0x39, 0x63c: 0x39, 0x63d: 0x39, 0x63e: 0x39, 0x63f: 0xe6, + // Block 0x19, offset 0x640 + 0x650: 0x0b, 0x651: 0x0c, 0x653: 0x0d, 0x656: 0x0e, 0x657: 0x06, + 0x658: 0x0f, 0x65a: 0x10, 0x65b: 0x11, 0x65c: 0x12, 0x65d: 0x13, 0x65e: 0x14, 0x65f: 0x15, + 0x660: 0x06, 0x661: 0x06, 0x662: 0x06, 0x663: 0x06, 0x664: 0x06, 0x665: 0x06, 0x666: 0x06, 0x667: 0x06, + 0x668: 0x06, 0x669: 0x06, 0x66a: 0x06, 0x66b: 0x06, 0x66c: 0x06, 0x66d: 0x06, 0x66e: 0x06, 0x66f: 0x16, + 0x670: 0x06, 0x671: 0x06, 0x672: 0x06, 0x673: 0x06, 0x674: 0x06, 0x675: 0x06, 0x676: 0x06, 0x677: 0x06, + 0x678: 0x06, 0x679: 0x06, 0x67a: 0x06, 0x67b: 0x06, 0x67c: 0x06, 0x67d: 0x06, 0x67e: 0x06, 0x67f: 0x16, + // Block 0x1a, offset 0x680 + 0x680: 0xf2, 0x681: 0x08, 0x684: 0x08, 0x685: 0x08, 0x686: 0x08, 0x687: 0x09, + // Block 0x1b, offset 0x6c0 + 0x6c0: 0x5b, 0x6c1: 0x5b, 0x6c2: 0x5b, 0x6c3: 0x5b, 0x6c4: 0x5b, 0x6c5: 0x5b, 0x6c6: 0x5b, 0x6c7: 0x5b, + 0x6c8: 0x5b, 0x6c9: 0x5b, 0x6ca: 0x5b, 0x6cb: 0x5b, 0x6cc: 0x5b, 0x6cd: 0x5b, 0x6ce: 0x5b, 0x6cf: 0x5b, + 0x6d0: 0x5b, 0x6d1: 0x5b, 0x6d2: 0x5b, 0x6d3: 0x5b, 0x6d4: 0x5b, 0x6d5: 0x5b, 0x6d6: 0x5b, 0x6d7: 0x5b, + 0x6d8: 0x5b, 0x6d9: 0x5b, 0x6da: 0x5b, 0x6db: 0x5b, 0x6dc: 0x5b, 0x6dd: 0x5b, 0x6de: 0x5b, 0x6df: 0x5b, + 0x6e0: 0x5b, 0x6e1: 0x5b, 0x6e2: 0x5b, 0x6e3: 0x5b, 0x6e4: 0x5b, 0x6e5: 0x5b, 0x6e6: 0x5b, 0x6e7: 0x5b, + 0x6e8: 0x5b, 0x6e9: 0x5b, 0x6ea: 0x5b, 0x6eb: 0x5b, 0x6ec: 0x5b, 0x6ed: 0x5b, 0x6ee: 0x5b, 0x6ef: 0x5b, + 0x6f0: 0x5b, 0x6f1: 0x5b, 0x6f2: 0x5b, 0x6f3: 0x5b, 0x6f4: 0x5b, 0x6f5: 0x5b, 0x6f6: 0x5b, 0x6f7: 0x5b, + 0x6f8: 0x5b, 0x6f9: 0x5b, 0x6fa: 0x5b, 0x6fb: 0x5b, 0x6fc: 0x5b, 0x6fd: 0x5b, 0x6fe: 0x5b, 0x6ff: 0xf3, + // Block 0x1c, offset 0x700 + 0x720: 0x18, + 0x730: 0x09, 0x731: 0x09, 0x732: 0x09, 0x733: 0x09, 0x734: 0x09, 0x735: 0x09, 0x736: 0x09, 0x737: 0x09, + 0x738: 0x09, 0x739: 0x09, 0x73a: 0x09, 0x73b: 0x09, 0x73c: 0x09, 0x73d: 0x09, 0x73e: 0x09, 0x73f: 0x19, + // Block 0x1d, offset 0x740 + 0x740: 0x09, 0x741: 0x09, 0x742: 0x09, 0x743: 0x09, 0x744: 0x09, 0x745: 0x09, 0x746: 0x09, 0x747: 0x09, + 0x748: 0x09, 0x749: 0x09, 0x74a: 0x09, 0x74b: 0x09, 0x74c: 0x09, 0x74d: 0x09, 0x74e: 0x09, 0x74f: 0x19, +} diff --git a/vendor/github.com/clipperhouse/displaywidth/truncate.go b/vendor/github.com/clipperhouse/displaywidth/truncate.go new file mode 100644 index 00000000..b3e696f4 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/truncate.go @@ -0,0 +1,149 @@ +package displaywidth + +import ( + "strings" + + "github.com/clipperhouse/uax29/v2/graphemes" +) + +// TruncateString truncates a string to the given maxWidth, and appends the +// given tail if the string is truncated. +// +// It ensures the visible width, including the width of the tail, is less than or +// equal to maxWidth. +// +// When [Options.ControlSequences] is true, 7-bit ANSI escape sequences that +// appear after the truncation point are preserved in the output. This ensures +// that escape sequences such as SGR resets are not lost, preventing color +// bleed in terminal output. +// +// [Options.ControlSequences8Bit] is ignored by truncation. 8-bit C1 byte values +// (0x80-0x9F) overlap with UTF-8 multi-byte encoding, so manipulating them +// during truncation can shift byte boundaries and form unintended visible +// characters. Use [Options.String] or [Options.Bytes] for 8-bit-aware width +// measurement. +func (options Options) TruncateString(s string, maxWidth int, tail string) string { + // We deliberately ignore ControlSequences8Bit for truncation, see above. + options.ControlSequences8Bit = false + + maxWidthWithoutTail := maxWidth - options.String(tail) + + var pos, total int + g := graphemes.FromString(s) + g.AnsiEscapeSequences = options.ControlSequences + + for g.Next() { + gw := graphemeWidth(g.Value(), options) + if total+gw <= maxWidthWithoutTail { + pos = g.End() + } + total += gw + if total > maxWidth { + if options.ControlSequences { + // Build result with trailing 7-bit ANSI escape sequences preserved + var b strings.Builder + b.Grow(len(s) + len(tail)) // at most original + tail + b.WriteString(s[:pos]) + b.WriteString(tail) + + rem := graphemes.FromString(s[pos:]) + rem.AnsiEscapeSequences = options.ControlSequences + + for rem.Next() { + v := rem.Value() + // Only preserve 7-bit escapes (ESC = 0x1B) that measure + // as zero-width on their own; some sequences (e.g. SOS) + // are only valid in their original context. + if len(v) > 0 && v[0] == 0x1B && options.String(v) == 0 { + b.WriteString(v) + } + } + return b.String() + } + return s[:pos] + tail + } + } + // No truncation + return s +} + +// TruncateString truncates a string to the given maxWidth, and appends the +// given tail if the string is truncated. +// +// It ensures the total width, including the width of the tail, is less than or +// equal to maxWidth. +func TruncateString(s string, maxWidth int, tail string) string { + return DefaultOptions.TruncateString(s, maxWidth, tail) +} + +// TruncateBytes truncates a []byte to the given maxWidth, and appends the +// given tail if the []byte is truncated. +// +// It ensures the visible width, including the width of the tail, is less than or +// equal to maxWidth. +// +// When [Options.ControlSequences] is true, 7-bit ANSI escape sequences that +// appear after the truncation point are preserved in the output. This ensures +// that escape sequences such as SGR resets are not lost, preventing color +// bleed in terminal output. +// +// [Options.ControlSequences8Bit] is ignored by truncation. 8-bit C1 byte values +// (0x80-0x9F) overlap with UTF-8 multi-byte encoding, so manipulating them +// during truncation can shift byte boundaries and form unintended visible +// characters. Use [Options.String] or [Options.Bytes] for 8-bit-aware width +// measurement. +func (options Options) TruncateBytes(s []byte, maxWidth int, tail []byte) []byte { + // We deliberately ignore ControlSequences8Bit for truncation, see above. + options.ControlSequences8Bit = false + + maxWidthWithoutTail := maxWidth - options.Bytes(tail) + + var pos, total int + g := graphemes.FromBytes(s) + g.AnsiEscapeSequences = options.ControlSequences + + for g.Next() { + gw := graphemeWidth(g.Value(), options) + if total+gw <= maxWidthWithoutTail { + pos = g.End() + } + total += gw + if total > maxWidth { + if options.ControlSequences { + // Build result with trailing 7-bit ANSI escape sequences preserved + result := make([]byte, 0, len(s)+len(tail)) // at most original + tail + result = append(result, s[:pos]...) + result = append(result, tail...) + + rem := graphemes.FromBytes(s[pos:]) + rem.AnsiEscapeSequences = options.ControlSequences + + for rem.Next() { + v := rem.Value() + // Only preserve 7-bit escapes (ESC = 0x1B) that measure + // as zero-width on their own; some sequences (e.g. SOS) + // are only valid in their original context. + if len(v) > 0 && v[0] == 0x1B && options.Bytes(v) == 0 { + result = append(result, v...) + } + } + return result + } + result := make([]byte, 0, pos+len(tail)) + result = append(result, s[:pos]...) + result = append(result, tail...) + return result + } + } + // No truncation + return s +} + +// TruncateBytes truncates a []byte to the given maxWidth, and appends the +// given tail if the []byte is truncated. +// +// It ensures the total width, including the width of the tail, is less than or +// equal to maxWidth. +func TruncateBytes(s []byte, maxWidth int, tail []byte) []byte { + return DefaultOptions.TruncateBytes(s, maxWidth, tail) +} diff --git a/vendor/github.com/clipperhouse/displaywidth/width.go b/vendor/github.com/clipperhouse/displaywidth/width.go new file mode 100644 index 00000000..f6e0ab7f --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/width.go @@ -0,0 +1,239 @@ +package displaywidth + +import ( + "unicode/utf8" + + "github.com/clipperhouse/uax29/v2/graphemes" +) + +// String calculates the display width of a string, +// by iterating over grapheme clusters in the string +// and summing their widths. +func String(s string) int { + return DefaultOptions.String(s) +} + +// String calculates the display width of a string, for the given options, by +// iterating over grapheme clusters in the string and summing their widths. +func (options Options) String(s string) int { + width := 0 + pos := 0 + + for pos < len(s) { + // Try ASCII optimization + asciiLen := printableASCIILength(s[pos:]) + if asciiLen > 0 { + width += asciiLen + pos += asciiLen + continue + } + + // Not ASCII, use grapheme parsing + g := graphemes.FromString(s[pos:]) + g.AnsiEscapeSequences = options.ControlSequences + g.AnsiEscapeSequences8Bit = options.ControlSequences8Bit + + start := pos + + for g.Next() { + v := g.Value() + width += graphemeWidth(v, options) + pos += len(v) + + // Quick check: if remaining might have printable ASCII, break to outer loop + if pos < len(s) && s[pos] >= 0x20 && s[pos] <= 0x7E { + break + } + } + + // Defensive, should not happen: if no progress was made, + // skip a byte to prevent infinite loop. Only applies if + // the grapheme parser misbehaves. + if pos == start { + pos++ + } + } + + return width +} + +// Bytes calculates the display width of a []byte, +// by iterating over grapheme clusters in the byte slice +// and summing their widths. +func Bytes(s []byte) int { + return DefaultOptions.Bytes(s) +} + +// Bytes calculates the display width of a []byte, for the given options, by +// iterating over grapheme clusters in the slice and summing their widths. +func (options Options) Bytes(s []byte) int { + width := 0 + pos := 0 + + for pos < len(s) { + // Try ASCII optimization + asciiLen := printableASCIILength(s[pos:]) + if asciiLen > 0 { + width += asciiLen + pos += asciiLen + continue + } + + // Not ASCII, use grapheme parsing + g := graphemes.FromBytes(s[pos:]) + g.AnsiEscapeSequences = options.ControlSequences + g.AnsiEscapeSequences8Bit = options.ControlSequences8Bit + + start := pos + + for g.Next() { + v := g.Value() + width += graphemeWidth(v, options) + pos += len(v) + + // Quick check: if remaining might have printable ASCII, break to outer loop + if pos < len(s) && s[pos] >= 0x20 && s[pos] <= 0x7E { + break + } + } + + // Defensive, should not happen: if no progress was made, + // skip a byte to prevent infinite loop. Only applies if + // the grapheme parser misbehaves. + if pos == start { + pos++ + } + } + + return width +} + +// Rune calculates the display width of a rune. You +// should almost certainly use [String] or [Bytes] for +// most purposes. +// +// The smallest unit of display width is a grapheme +// cluster, not a rune. Iterating over runes to measure +// width is incorrect in many cases. +func Rune(r rune) int { + return DefaultOptions.Rune(r) +} + +// Rune calculates the display width of a rune, for the given options. +// +// You should almost certainly use [String] or [Bytes] for most purposes. +// +// The smallest unit of display width is a grapheme cluster, not a rune. +// Iterating over runes to measure width is incorrect in many cases. +func (options Options) Rune(r rune) int { + if r < utf8.RuneSelf { + return asciiWidth(byte(r)) + } + + // Surrogates (U+D800-U+DFFF) are invalid UTF-8. + if r >= 0xD800 && r <= 0xDFFF { + return 0 + } + + var buf [4]byte + n := utf8.EncodeRune(buf[:], r) + + // Skip the grapheme iterator + return graphemeWidth(buf[:n], options) +} + +const _Default property = 0 + +// graphemeWidth returns the display width of a grapheme cluster. +// The passed string must be a single grapheme cluster. +func graphemeWidth[T ~string | []byte](s T, options Options) int { + if len(s) == 0 { + return 0 + } + + // C1 controls (0x80-0x9F) are zero-width when 8-bit control sequences + // are enabled. This must be checked before the single-byte optimization + // below, which would otherwise return width 1 for these bytes. + if options.ControlSequences8Bit && s[0] >= 0x80 && s[0] <= 0x9F { + return 0 + } + + // Optimization: single-byte graphemes need no property lookup + if len(s) == 1 { + return asciiWidth(s[0]) + } + + // Multi-byte grapheme clusters led by a C0 control (0x00-0x1F) + if s[0] <= 0x1F { + return 0 + } + + p, sz := lookup(s) + prop := property(p) + + // Variation Selector 16 (VS16) requests emoji presentation + if prop != _Wide && sz > 0 && len(s) >= sz+3 { + vs := s[sz : sz+3] + if isVS16(vs) { + prop = _Wide + } + // VS15 (0x8E) requests text presentation but does not affect width, + // in my reading of Unicode TR51. Falls through to return the base + // character's property. + } + + if options.EastAsianWidth && prop == _East_Asian_Ambiguous { + prop = _Wide + } + + if prop > upperBound { + prop = _Default + } + + return propertyWidths[prop] +} + +func asciiWidth(b byte) int { + if b <= 0x1F || b == 0x7F { + return 0 + } + return 1 +} + +// printableASCIILength returns the length of consecutive printable ASCII bytes +// starting at the beginning of s. +func printableASCIILength[T string | []byte](s T) int { + i := 0 + for ; i < len(s); i++ { + b := s[i] + // Printable ASCII is 0x20-0x7E (space through tilde) + if b < 0x20 || b > 0x7E { + break + } + } + + // If the next byte is non-ASCII (>= 0x80), back off by 1. The grapheme + // parser may group the last ASCII byte with subsequent non-ASCII bytes, + // such as combining marks. + if i > 0 && i < len(s) && s[i] >= 0x80 { + i-- + } + + return i +} + +// isVS16 checks if the slice matches VS16 (U+FE0F) UTF-8 encoding +// (EF B8 8F). It assumes len(s) >= 3. +func isVS16[T ~string | []byte](s T) bool { + return s[0] == 0xEF && s[1] == 0xB8 && s[2] == 0x8F +} + +// propertyWidths is a jump table of sorts, instead of a switch +var propertyWidths = [4]int{ + _Default: 1, + _Zero_Width: 0, + _Wide: 2, + _East_Asian_Ambiguous: 1, +} + +const upperBound = property(len(propertyWidths) - 1) diff --git a/vendor/github.com/clipperhouse/stringish/README.md b/vendor/github.com/clipperhouse/stringish/README.md deleted file mode 100644 index fa1f7cc6..00000000 --- a/vendor/github.com/clipperhouse/stringish/README.md +++ /dev/null @@ -1,64 +0,0 @@ -# stringish - -A small Go module that provides a generic type constraint for “string-like” -data, and a utf8 package that works with both strings and byte slices -without conversions. - -```go -type Interface interface { - ~[]byte | ~string -} -``` - -[![Go Reference](https://pkg.go.dev/badge/github.com/clipperhouse/stringish/utf8.svg)](https://pkg.go.dev/github.com/clipperhouse/stringish/utf8) -[![Test Status](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml/badge.svg)](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml) - -## Install - -``` -go get github.com/clipperhouse/stringish -``` - -## Examples - -```go -import ( - "github.com/clipperhouse/stringish" - "github.com/clipperhouse/stringish/utf8" -) - -s := "Hello, 世界" -r, size := utf8.DecodeRune(s) // not DecodeRuneInString 🎉 - -b := []byte("Hello, 世界") -r, size = utf8.DecodeRune(b) // same API! - -func MyFoo[T stringish.Interface](s T) T { - // pass a string or a []byte - // iterate, slice, transform, whatever -} -``` - -## Motivation - -Sometimes we want APIs to accept `string` or `[]byte` without having to convert -between those types. That conversion usually allocates! - -By implementing with `stringish.Interface`, we can have a single API, and -single implementation for both types: one `Foo` instead of `Foo` and -`FooString`. - -We have converted the -[`unicode/utf8` package](https://github.com/clipperhouse/stringish/blob/main/utf8/utf8.go) -as an example -- note the absence of`*InString` funcs. We might look at `x/text` -next. - -## Used by - -- clipperhouse/uax29: [stringish trie](https://github.com/clipperhouse/uax29/blob/master/graphemes/trie.go#L27), [stringish iterator](https://github.com/clipperhouse/uax29/blob/master/internal/iterators/iterator.go#L9), [stringish SplitFunc](https://github.com/clipperhouse/uax29/blob/master/graphemes/splitfunc.go#L21) - -- [clipperhouse/displaywidth](https://github.com/clipperhouse/displaywidth) - -## Prior discussion - -- [Consideration of similar by the Go team](https://github.com/golang/go/issues/48643) diff --git a/vendor/github.com/clipperhouse/stringish/interface.go b/vendor/github.com/clipperhouse/stringish/interface.go deleted file mode 100644 index adfeab61..00000000 --- a/vendor/github.com/clipperhouse/stringish/interface.go +++ /dev/null @@ -1,5 +0,0 @@ -package stringish - -type Interface interface { - ~[]byte | ~string -} diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md b/vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md index dc14d11e..3f8a5e3f 100644 --- a/vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md @@ -1,4 +1,4 @@ -An implementation of grapheme cluster boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) (UAX 29), for Unicode version 15.0.0. +An implementation of grapheme cluster boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) (UAX 29), for Unicode 17. [![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/graphemes.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/graphemes) ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) @@ -7,18 +7,17 @@ An implementation of grapheme cluster boundaries from [Unicode text segmentation ## Quick start ``` -go get "github.com/clipperhouse/uax29/v2/graphemes" +go get github.com/clipperhouse/uax29/v2/graphemes ``` ```go import "github.com/clipperhouse/uax29/v2/graphemes" text := "Hello, 世界. Nice dog! 👍🐶" +g := graphemes.FromString(text) -tokens := graphemes.FromString(text) - -for tokens.Next() { // Next() returns true until end of data - fmt.Println(tokens.Value()) // Do something with the current grapheme +for g.Next() { // Next() returns true until end of data + fmt.Println(g.Value()) // Do something with the current grapheme } ``` @@ -26,7 +25,7 @@ _A grapheme is a “single visible character”, which might be a simple as a si ## Conformance -We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-26.html#Tests29). +We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-36.html#Tests29). ![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg) ![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg) @@ -37,11 +36,10 @@ We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-26.html#Te ```go text := "Hello, 世界. Nice dog! 👍🐶" +g := graphemes.FromString(text) -tokens := graphemes.FromString(text) - -for tokens.Next() { // Next() returns true until end of data - fmt.Println(tokens.Value()) // Do something with the current grapheme +for g.Next() { // Next() returns true until end of data + fmt.Println(g.Value()) // Do something with the current grapheme } ``` @@ -50,15 +48,15 @@ for tokens.Next() { // Next() returns true until end of data `FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods. ```go -r := getYourReader() // from a file or network maybe -tokens := graphemes.FromReader(r) +r := getYourReader() // from a file or network maybe +g := graphemes.FromReader(r) -for tokens.Scan() { // Scan() returns true until error or EOF - fmt.Println(tokens.Text()) // Do something with the current grapheme +for g.Scan() { // Scan() returns true until error or EOF + fmt.Println(g.Text()) // Do something with the current grapheme } -if tokens.Err() != nil { // Check the error - log.Fatal(tokens.Err()) +if g.Err() != nil { // Check the error + log.Fatal(g.Err()) } ``` @@ -67,24 +65,52 @@ if tokens.Err() != nil { // Check the error ```go b := []byte("Hello, 世界. Nice dog! 👍🐶") -tokens := graphemes.FromBytes(b) +g := graphemes.FromBytes(b) -for tokens.Next() { // Next() returns true until end of data - fmt.Println(tokens.Value()) // Do something with the current grapheme +for g.Next() { // Next() returns true until end of data + fmt.Println(g.Value()) // Do something with the current grapheme } ``` -### Benchmarks +### ANSI escape sequences + +By the UAX 29 specification, ANSI escape sequences are not grapheme clusters. To treat 7-bit ANSI escape sequences as a single cluster, set `AnsiEscapeSequences` to true. + +```go +text := "Hello, \x1b[31mworld\x1b[0m!" +g := graphemes.FromString(text) +g.AnsiEscapeSequences = true + +for g.Next() { + fmt.Println(g.Value()) +} +``` -On a Mac M2 laptop, we see around 200MB/s, or around 100 million graphemes per second, and no allocations. +To also parse 8-bit C1 controls (non-UTF-8 bytes), set `AnsiEscapeSequences8Bit` to true. + +```go +g.AnsiEscapeSequences = true // 7-bit forms (ESC ...) +g.AnsiEscapeSequences8Bit = true // 8-bit C1 forms (0x80-0x9F), not valid UTF-8 +``` + +For ESC-initiated (7-bit) control strings, only 7-bit terminators are recognized. +For C1-initiated (8-bit) control strings, only C1 ST (`0x9C`) is recognized as ST. + +We implement [ECMA-48](https://ecma-international.org/publications-and-standards/standards/ecma-48/) control codes in both 7-bit and 8-bit representations. 8-bit control codes are not UTF-8 encoded and are not valid UTF-8, caveat emptor. + +### Benchmarks ``` goos: darwin goarch: arm64 pkg: github.com/clipperhouse/uax29/graphemes/comparative cpu: Apple M2 -BenchmarkGraphemes/clipperhouse/uax29-8 173805 ns/op 201.16 MB/s 0 B/op 0 allocs/op -BenchmarkGraphemes/rivo/uniseg-8 2045128 ns/op 17.10 MB/s 0 B/op 0 allocs/op + +BenchmarkGraphemesMixed/clipperhouse/uax29-8 142635 ns/op 245.12 MB/s 0 B/op 0 allocs/op +BenchmarkGraphemesMixed/rivo/uniseg-8 2018284 ns/op 17.32 MB/s 0 B/op 0 allocs/op + +BenchmarkGraphemesASCII/clipperhouse/uax29-8 8846 ns/op 508.73 MB/s 0 B/op 0 allocs/op +BenchmarkGraphemesASCII/rivo/uniseg-8 366760 ns/op 12.27 MB/s 0 B/op 0 allocs/op ``` ### Invalid inputs diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi.go b/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi.go new file mode 100644 index 00000000..9cd09b42 --- /dev/null +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi.go @@ -0,0 +1,138 @@ +package graphemes + +// ansiEscapeLength returns the byte length of a valid 7-bit ANSI escape +// sequence at the start of data, or 0 if none. +// +// Recognized forms (ECMA-48 / ISO 6429): +// - CSI: ESC [ then parameter bytes (0x30-0x3F), intermediate (0x20-0x2F), final (0x40-0x7E) +// - OSC: ESC ] then payload until BEL (0x07), 7-bit ST (ESC \), CAN (0x18), or SUB (0x1A) +// - DCS, SOS, PM, APC: ESC P/X/^/_ then payload until 7-bit ST (ESC \), CAN, or SUB +// - Two-byte: ESC + Fe/Fs (0x40-0x7E excluding above), or Fp (0x30-0x3F), or nF (0x20-0x2F then final) +func ansiEscapeLength[T ~string | ~[]byte](data T) int { + n := len(data) + if n < 2 || data[0] != esc { + return 0 + } + + b1 := data[1] + switch b1 { + case '[': // CSI + body := csiBodyLength(data[2:]) + if body == 0 { + return 0 + } + return 2 + body + case ']': // OSC - allows BEL or 7-bit ST terminator + body := oscLength(data[2:]) + if body < 0 { + return 0 + } + return 2 + body + case 'P', 'X', '^', '_': // DCS, SOS, PM, APC + body := stSequenceLength(data[2:]) + if body < 0 { + return 0 + } + return 2 + body + } + + if b1 >= 0x40 && b1 <= 0x7E { + // Fe/Fs two-byte; [ ] P X ^ _ handled above + return 2 + } + if b1 >= 0x30 && b1 <= 0x3F { + // Fp (private) two-byte + return 2 + } + if b1 >= 0x20 && b1 <= 0x2F { + // nF: intermediates then one final (0x30-0x7E) + i := 2 + for i < n && data[i] >= 0x20 && data[i] <= 0x2F { + i++ + } + if i < n && data[i] >= 0x30 && data[i] <= 0x7E { + return i + 1 + } + return 0 + } + + return 0 +} + +// csiBodyLength returns the length of the CSI body (param/intermediate/final bytes). +// data is the slice after "ESC [". +// Per ECMA-48, the CSI body has the form: +// +// parameters (0x30–0x3F)*, intermediates (0x20–0x2F)*, final (0x40–0x7E) +// +// Once an intermediate byte is seen, subsequent parameter bytes are invalid. +func csiBodyLength[T ~string | ~[]byte](data T) int { + seenIntermediate := false + for i := 0; i < len(data); i++ { + b := data[i] + if b >= 0x30 && b <= 0x3F { + if seenIntermediate { + return 0 + } + continue + } + if b >= 0x20 && b <= 0x2F { + seenIntermediate = true + continue + } + if b >= 0x40 && b <= 0x7E { + return i + 1 + } + return 0 + } + return 0 +} + +// oscLength returns the length of the OSC body. +// data is the slice after "ESC ]". +// +// Returns: +// - n >= 0: consumed body length (includes BEL/ST terminator when present) +// - -1: not terminated in the provided data +// +// OSC accepts BEL (0x07) or 7-bit ST (ESC \) as terminators by widespread convention. +// Per ECMA-48, CAN (0x18) and SUB (0x1A) cancel the control string; in that +// case they are not part of the OSC sequence length. +func oscLength[T ~string | ~[]byte](data T) int { + for i := 0; i < len(data); i++ { + b := data[i] + if b == bel { + return i + 1 + } + if b == can || b == sub { + return i + } + if b == esc && i+1 < len(data) && data[i+1] == '\\' { + return i + 2 + } + } + return -1 +} + +// stSequenceLength returns the length of a control-string body. +// data is the slice after "ESC x". +// +// Returns: +// - n >= 0: consumed body length (includes ST terminator when present) +// - -1: not terminated in the provided data +// +// Used for DCS, SOS, PM, and APC, which per ECMA-48 terminate with ST. +// ST here is the 7-bit form (ESC \). +// CAN (0x18) and SUB (0x1A) cancel the control string; in that case they are +// not part of the sequence length. +func stSequenceLength[T ~string | ~[]byte](data T) int { + for i := 0; i < len(data); i++ { + if data[i] == can || data[i] == sub { + return i + } + if data[i] == esc && i+1 < len(data) && data[i+1] == '\\' { + return i + 2 + } + } + return -1 +} diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi8.go b/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi8.go new file mode 100644 index 00000000..d9b0c48b --- /dev/null +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi8.go @@ -0,0 +1,79 @@ +package graphemes + +// ansiEscapeLength8Bit returns the byte length of a valid 8-bit C1 ANSI +// sequence at the start of data, or 0 if none. +// +// Recognized forms (ECMA-48 / ISO 6429): +// - C1 CSI (0x9B) body as parameter/intermediate/final bytes +// - C1 OSC (0x9D) body terminated by BEL, C1 ST, CAN, or SUB +// - C1 DCS/SOS/PM/APC (0x90/0x98/0x9E/0x9F) body terminated by C1 ST, CAN, or SUB +// - Standalone C1 controls (0x80..0x9F not listed above): single byte +func ansiEscapeLength8Bit[T ~string | ~[]byte](data T) int { + if len(data) == 0 { + return 0 + } + + switch data[0] { + case 0x9B: // C1 CSI + body := csiBodyLength(data[1:]) + if body == 0 { + return 0 + } + return 1 + body + case 0x9D: // C1 OSC + body := oscLengthC1(data[1:]) + if body < 0 { + return 0 + } + return 1 + body + case 0x90, 0x98, 0x9E, 0x9F: // C1 DCS, SOS, PM, APC + body := stSequenceLengthC1(data[1:]) + if body < 0 { + return 0 + } + return 1 + body + default: + if data[0] >= 0x80 && data[0] <= 0x9F { + return 1 + } + } + + return 0 +} + +// oscLengthC1 returns the length of a C1 OSC body. +// data is the slice after the C1 OSC initiator (0x9D). +// +// Returns: +// - n >= 0: consumed body length (includes BEL/ST terminator when present) +// - -1: not terminated in the provided data +// +// Terminators: BEL (0x07) or C1 ST (0x9C). +// CAN (0x18) and SUB (0x1A) cancel the control string. +func oscLengthC1[T ~string | ~[]byte](data T) int { + for i := 0; i < len(data); i++ { + b := data[i] + if b == bel || b == st { + return i + 1 + } + if b == can || b == sub { + return i + } + } + return -1 +} + +// stSequenceLengthC1 parses DCS/SOS/PM/APC bodies that terminate with C1 ST +// (0x9C), or are canceled by CAN/SUB. +func stSequenceLengthC1[T ~string | ~[]byte](data T) int { + for i := 0; i < len(data); i++ { + b := data[i] + if b == can || b == sub { + return i + } + if b == st { + return i + 1 + } + } + return -1 +} diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go b/vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go index 1eaaa534..d37d43d7 100644 --- a/vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go @@ -1,12 +1,44 @@ package graphemes -import ( - "github.com/clipperhouse/stringish" - "github.com/clipperhouse/uax29/v2/internal/iterators" -) +import "unicode/utf8" + +// FromString returns an iterator for the grapheme clusters in the input string. +// Iterate while Next() is true, and access the grapheme via Value(). +func FromString(s string) *Iterator[string] { + return &Iterator[string]{ + split: splitFuncString, + data: s, + } +} -type Iterator[T stringish.Interface] struct { - *iterators.Iterator[T] +// FromBytes returns an iterator for the grapheme clusters in the input bytes. +// Iterate while Next() is true, and access the grapheme via Value(). +func FromBytes(b []byte) *Iterator[[]byte] { + return &Iterator[[]byte]{ + split: splitFuncBytes, + data: b, + } +} + +// Iterator is a generic iterator for grapheme clusters in strings or byte slices, +// with an ASCII hot path optimization. +type Iterator[T ~string | ~[]byte] struct { + split func(T, bool) (int, T, error) + data T + pos int + start int + // AnsiEscapeSequences treats 7-bit ANSI escape sequences (ECMA-48) as + // single grapheme clusters when true. The default is false. + // + // 8-bit controls are not enabled by this option. See [AnsiEscapeSequences8Bit]. + AnsiEscapeSequences bool + // AnsiEscapeSequences8Bit treats 8-bit C1 ANSI escape sequences (ECMA-48) as single + // grapheme clusters when true. The default is false. + // + // 8-bit control bytes are not UTF-8 encoded, i.e. not valid UTF-8. If you + // choose this option, you are choosing to interpret non-UTF-8 data, caveat + // emptor. + AnsiEscapeSequences8Bit bool } var ( @@ -14,18 +46,99 @@ var ( splitFuncBytes = splitFunc[[]byte] ) -// FromString returns an iterator for the grapheme clusters in the input string. -// Iterate while Next() is true, and access the grapheme via Value(). -func FromString(s string) Iterator[string] { - return Iterator[string]{ - iterators.New(splitFuncString, s), +const ( + esc = 0x1B + cr = 0x0D + bel = 0x07 + can = 0x18 + sub = 0x1A + st = 0x9C +) + +// Next advances the iterator to the next grapheme cluster. +// Returns false when there are no more grapheme clusters. +func (iter *Iterator[T]) Next() bool { + if iter.pos >= len(iter.data) { + return false } + iter.start = iter.pos + + b := iter.data[iter.pos] + if iter.AnsiEscapeSequences && b == esc { + if a := ansiEscapeLength(iter.data[iter.pos:]); a > 0 { + iter.pos += a + return true + } + } + if iter.AnsiEscapeSequences8Bit && b >= 0x80 && b <= 0x9F { + if a := ansiEscapeLength8Bit(iter.data[iter.pos:]); a > 0 { + iter.pos += a + return true + } + } + + // ASCII hot path: any ASCII is one grapheme when next byte is ASCII or end. + if b < utf8.RuneSelf && b != cr { + if iter.pos+1 >= len(iter.data) || iter.data[iter.pos+1] < utf8.RuneSelf { + iter.pos++ + return true + } + } + + // Fall back to UAX29 grapheme parsing + remaining := iter.data[iter.pos:] + advance, _, err := iter.split(remaining, true) + if err != nil { + panic(err) + } + if advance <= 0 { + panic("splitFunc returned a zero or negative advance") + } + iter.pos += advance + if iter.pos > len(iter.data) { + panic("splitFunc advanced beyond end of data") + } + return true } -// FromBytes returns an iterator for the grapheme clusters in the input bytes. -// Iterate while Next() is true, and access the grapheme via Value(). -func FromBytes(b []byte) Iterator[[]byte] { - return Iterator[[]byte]{ - iterators.New(splitFuncBytes, b), +// Value returns the current grapheme cluster. +func (iter *Iterator[T]) Value() T { + return iter.data[iter.start:iter.pos] +} + +// Start returns the byte position of the current grapheme in the original data. +func (iter *Iterator[T]) Start() int { + return iter.start +} + +// End returns the byte position after the current grapheme in the original data. +func (iter *Iterator[T]) End() int { + return iter.pos +} + +// Reset resets the iterator to the beginning of the data. +func (iter *Iterator[T]) Reset() { + iter.start = 0 + iter.pos = 0 +} + +// SetText sets the data for the iterator to operate on, and resets all state. +func (iter *Iterator[T]) SetText(data T) { + iter.data = data + iter.start = 0 + iter.pos = 0 +} + +// First returns the first grapheme cluster without advancing the iterator. +func (iter *Iterator[T]) First() T { + if len(iter.data) == 0 { + return iter.data } + + // Use a copy to leverage Next()'s ASCII optimization + cp := *iter + cp.pos = 0 + cp.start = 0 + cp.Next() + return cp.Value() } diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go b/vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go index cbe1ec9e..0ac7c6fb 100644 --- a/vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go @@ -2,8 +2,6 @@ package graphemes import ( "bufio" - - "github.com/clipperhouse/stringish" ) // is determines if lookup intersects propert(ies) @@ -13,12 +11,22 @@ func (lookup property) is(properties property) bool { const _Ignore = _Extend +// incbState tracks state for GB9c rule (Indic conjunct clusters) +// Pattern: Consonant (Extend|Linker)* Linker (Extend|Linker)* × Consonant +type incbState int + +const ( + incbNone incbState = iota // initial/reset + incbConsonant // seen Consonant, awaiting Linker + incbLinker // seen Consonant and Linker (conjunct ready) +) + // SplitFunc is a bufio.SplitFunc implementation of Unicode grapheme cluster segmentation, for use with bufio.Scanner. // // See https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries. var SplitFunc bufio.SplitFunc = splitFunc[[]byte] -func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, err error) { +func splitFunc[T ~string | ~[]byte](data T, atEOF bool) (advance int, token T, err error) { var empty T if len(data) == 0 { return 0, empty, nil @@ -30,6 +38,9 @@ func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, var lastLastExIgnore property = 0 // "last one before that" var regionalIndicatorCount int + // GB9c state: tracking Indic conjunct clusters + var incb incbState + // Rules are usually of the form Cat1 × Cat2; "current" refers to the first property // to the right of the ×, from which we look back or forward @@ -76,6 +87,23 @@ func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, lastExIgnore = last } + // Update GB9c state based on what we just advanced past + if last.is(_InCBConsonant | _InCBLinker | _InCBExtend) { + switch { + case last.is(_InCBConsonant): + if incb != incbLinker { + incb = incbConsonant + } + case last.is(_InCBLinker): + if incb >= incbConsonant { + incb = incbLinker + } + // case last.is(_InCBExtend): stay in current state + } + } else { + incb = incbNone + } + current, w = lookup(data[pos:]) if w == 0 { if atEOF { @@ -141,11 +169,14 @@ func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, } // https://unicode.org/reports/tr29/#GB9c - // TODO(clipperhouse): - // It appears to be added in Unicode 15.1.0: - // https://unicode.org/versions/Unicode15.1.0/#Migration - // This package currently supports Unicode 15.0.0, so - // out of scope for now + // Do not break within certain combinations with Indic_Conjunct_Break (InCB)=Linker. + if incb == incbLinker && current.is(_InCBConsonant) { + // After matching the pattern, reset state to start tracking a new pattern + // The current Consonant becomes the start of the new pattern + incb = incbConsonant + pos += w + continue + } // https://unicode.org/reports/tr29/#GB11 if current.is(_ExtendedPictographic) && last.is(_ZWJ) && lastLastExIgnore.is(_ExtendedPictographic) { diff --git a/vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go b/vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go index 8aaabfac..56192b7e 100644 --- a/vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go +++ b/vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go @@ -1,17 +1,18 @@ package graphemes -import "github.com/clipperhouse/stringish" - // generated by github.com/clipperhouse/uax29/v2 -// from https://www.unicode.org/Public/15.0.0/ucd/auxiliary/GraphemeBreakProperty.txt +// from https://www.unicode.org/Public/17.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -type property uint16 +type property uint32 const ( _CR property = 1 << iota _Control _Extend _ExtendedPictographic + _InCBConsonant + _InCBExtend + _InCBLinker _L _LF _LV @@ -27,7 +28,7 @@ const ( // lookup returns the trie value for the first UTF-8 encoding in s and // the width in bytes of this encoding. The size will be 0 if s does not // hold enough bytes to complete the encoding. len(s) must be greater than 0. -func lookup[T stringish.Interface](s T) (v property, sz int) { +func lookup[T ~string | ~[]byte](s T) (v property, sz int) { c0 := s[0] switch { case c0 < 0x80: // is ASCII @@ -87,7 +88,7 @@ func lookup[T stringish.Interface](s T) (v property, sz int) { return 0, 1 } -// graphemesTrie. Total size: 29120 bytes (28.44 KiB). Checksum: 80ad0c5ab9375f7. +// graphemesTrie. Total size: 61760 bytes (60.31 KiB). Checksum: af733ba94cd94ba6. // type graphemesTrie struct { } // func newGraphemesTrie(i int) *graphemesTrie { @@ -102,12 +103,12 @@ func lookupValue(n uint32, b byte) property { } } -// graphemesValues: 215 blocks, 13760 entries, 27520 bytes +// graphemesValues: 235 blocks, 15040 entries, 60160 bytes // The third block is the zero block. -var graphemesValues = [13760]property{ +var graphemesValues = [15040]property{ // Block 0x0, offset 0x0 0x00: 0x0002, 0x01: 0x0002, 0x02: 0x0002, 0x03: 0x0002, 0x04: 0x0002, 0x05: 0x0002, - 0x06: 0x0002, 0x07: 0x0002, 0x08: 0x0002, 0x09: 0x0002, 0x0a: 0x0020, 0x0b: 0x0002, + 0x06: 0x0002, 0x07: 0x0002, 0x08: 0x0002, 0x09: 0x0002, 0x0a: 0x0100, 0x0b: 0x0002, 0x0c: 0x0002, 0x0d: 0x0001, 0x0e: 0x0002, 0x0f: 0x0002, 0x10: 0x0002, 0x11: 0x0002, 0x12: 0x0002, 0x13: 0x0002, 0x14: 0x0002, 0x15: 0x0002, 0x16: 0x0002, 0x17: 0x0002, 0x18: 0x0002, 0x19: 0x0002, 0x1a: 0x0002, 0x1b: 0x0002, 0x1c: 0x0002, 0x1d: 0x0002, @@ -125,404 +126,503 @@ var graphemesValues = [13760]property{ 0xe9: 0x0008, 0xed: 0x0002, 0xee: 0x0008, // Block 0x4, offset 0x100 - 0x100: 0x0004, 0x101: 0x0004, 0x102: 0x0004, 0x103: 0x0004, 0x104: 0x0004, 0x105: 0x0004, - 0x106: 0x0004, 0x107: 0x0004, 0x108: 0x0004, 0x109: 0x0004, 0x10a: 0x0004, 0x10b: 0x0004, - 0x10c: 0x0004, 0x10d: 0x0004, 0x10e: 0x0004, 0x10f: 0x0004, 0x110: 0x0004, 0x111: 0x0004, - 0x112: 0x0004, 0x113: 0x0004, 0x114: 0x0004, 0x115: 0x0004, 0x116: 0x0004, 0x117: 0x0004, - 0x118: 0x0004, 0x119: 0x0004, 0x11a: 0x0004, 0x11b: 0x0004, 0x11c: 0x0004, 0x11d: 0x0004, - 0x11e: 0x0004, 0x11f: 0x0004, 0x120: 0x0004, 0x121: 0x0004, 0x122: 0x0004, 0x123: 0x0004, - 0x124: 0x0004, 0x125: 0x0004, 0x126: 0x0004, 0x127: 0x0004, 0x128: 0x0004, 0x129: 0x0004, - 0x12a: 0x0004, 0x12b: 0x0004, 0x12c: 0x0004, 0x12d: 0x0004, 0x12e: 0x0004, 0x12f: 0x0004, - 0x130: 0x0004, 0x131: 0x0004, 0x132: 0x0004, 0x133: 0x0004, 0x134: 0x0004, 0x135: 0x0004, - 0x136: 0x0004, 0x137: 0x0004, 0x138: 0x0004, 0x139: 0x0004, 0x13a: 0x0004, 0x13b: 0x0004, - 0x13c: 0x0004, 0x13d: 0x0004, 0x13e: 0x0004, 0x13f: 0x0004, + 0x100: 0x0024, 0x101: 0x0024, 0x102: 0x0024, 0x103: 0x0024, 0x104: 0x0024, 0x105: 0x0024, + 0x106: 0x0024, 0x107: 0x0024, 0x108: 0x0024, 0x109: 0x0024, 0x10a: 0x0024, 0x10b: 0x0024, + 0x10c: 0x0024, 0x10d: 0x0024, 0x10e: 0x0024, 0x10f: 0x0024, 0x110: 0x0024, 0x111: 0x0024, + 0x112: 0x0024, 0x113: 0x0024, 0x114: 0x0024, 0x115: 0x0024, 0x116: 0x0024, 0x117: 0x0024, + 0x118: 0x0024, 0x119: 0x0024, 0x11a: 0x0024, 0x11b: 0x0024, 0x11c: 0x0024, 0x11d: 0x0024, + 0x11e: 0x0024, 0x11f: 0x0024, 0x120: 0x0024, 0x121: 0x0024, 0x122: 0x0024, 0x123: 0x0024, + 0x124: 0x0024, 0x125: 0x0024, 0x126: 0x0024, 0x127: 0x0024, 0x128: 0x0024, 0x129: 0x0024, + 0x12a: 0x0024, 0x12b: 0x0024, 0x12c: 0x0024, 0x12d: 0x0024, 0x12e: 0x0024, 0x12f: 0x0024, + 0x130: 0x0024, 0x131: 0x0024, 0x132: 0x0024, 0x133: 0x0024, 0x134: 0x0024, 0x135: 0x0024, + 0x136: 0x0024, 0x137: 0x0024, 0x138: 0x0024, 0x139: 0x0024, 0x13a: 0x0024, 0x13b: 0x0024, + 0x13c: 0x0024, 0x13d: 0x0024, 0x13e: 0x0024, 0x13f: 0x0024, // Block 0x5, offset 0x140 - 0x140: 0x0004, 0x141: 0x0004, 0x142: 0x0004, 0x143: 0x0004, 0x144: 0x0004, 0x145: 0x0004, - 0x146: 0x0004, 0x147: 0x0004, 0x148: 0x0004, 0x149: 0x0004, 0x14a: 0x0004, 0x14b: 0x0004, - 0x14c: 0x0004, 0x14d: 0x0004, 0x14e: 0x0004, 0x14f: 0x0004, 0x150: 0x0004, 0x151: 0x0004, - 0x152: 0x0004, 0x153: 0x0004, 0x154: 0x0004, 0x155: 0x0004, 0x156: 0x0004, 0x157: 0x0004, - 0x158: 0x0004, 0x159: 0x0004, 0x15a: 0x0004, 0x15b: 0x0004, 0x15c: 0x0004, 0x15d: 0x0004, - 0x15e: 0x0004, 0x15f: 0x0004, 0x160: 0x0004, 0x161: 0x0004, 0x162: 0x0004, 0x163: 0x0004, - 0x164: 0x0004, 0x165: 0x0004, 0x166: 0x0004, 0x167: 0x0004, 0x168: 0x0004, 0x169: 0x0004, - 0x16a: 0x0004, 0x16b: 0x0004, 0x16c: 0x0004, 0x16d: 0x0004, 0x16e: 0x0004, 0x16f: 0x0004, + 0x140: 0x0024, 0x141: 0x0024, 0x142: 0x0024, 0x143: 0x0024, 0x144: 0x0024, 0x145: 0x0024, + 0x146: 0x0024, 0x147: 0x0024, 0x148: 0x0024, 0x149: 0x0024, 0x14a: 0x0024, 0x14b: 0x0024, + 0x14c: 0x0024, 0x14d: 0x0024, 0x14e: 0x0024, 0x14f: 0x0024, 0x150: 0x0024, 0x151: 0x0024, + 0x152: 0x0024, 0x153: 0x0024, 0x154: 0x0024, 0x155: 0x0024, 0x156: 0x0024, 0x157: 0x0024, + 0x158: 0x0024, 0x159: 0x0024, 0x15a: 0x0024, 0x15b: 0x0024, 0x15c: 0x0024, 0x15d: 0x0024, + 0x15e: 0x0024, 0x15f: 0x0024, 0x160: 0x0024, 0x161: 0x0024, 0x162: 0x0024, 0x163: 0x0024, + 0x164: 0x0024, 0x165: 0x0024, 0x166: 0x0024, 0x167: 0x0024, 0x168: 0x0024, 0x169: 0x0024, + 0x16a: 0x0024, 0x16b: 0x0024, 0x16c: 0x0024, 0x16d: 0x0024, 0x16e: 0x0024, 0x16f: 0x0024, // Block 0x6, offset 0x180 - 0x183: 0x0004, 0x184: 0x0004, 0x185: 0x0004, - 0x186: 0x0004, 0x187: 0x0004, 0x188: 0x0004, 0x189: 0x0004, + 0x183: 0x0024, 0x184: 0x0024, 0x185: 0x0024, + 0x186: 0x0024, 0x187: 0x0024, 0x188: 0x0024, 0x189: 0x0024, // Block 0x7, offset 0x1c0 - 0x1d1: 0x0004, - 0x1d2: 0x0004, 0x1d3: 0x0004, 0x1d4: 0x0004, 0x1d5: 0x0004, 0x1d6: 0x0004, 0x1d7: 0x0004, - 0x1d8: 0x0004, 0x1d9: 0x0004, 0x1da: 0x0004, 0x1db: 0x0004, 0x1dc: 0x0004, 0x1dd: 0x0004, - 0x1de: 0x0004, 0x1df: 0x0004, 0x1e0: 0x0004, 0x1e1: 0x0004, 0x1e2: 0x0004, 0x1e3: 0x0004, - 0x1e4: 0x0004, 0x1e5: 0x0004, 0x1e6: 0x0004, 0x1e7: 0x0004, 0x1e8: 0x0004, 0x1e9: 0x0004, - 0x1ea: 0x0004, 0x1eb: 0x0004, 0x1ec: 0x0004, 0x1ed: 0x0004, 0x1ee: 0x0004, 0x1ef: 0x0004, - 0x1f0: 0x0004, 0x1f1: 0x0004, 0x1f2: 0x0004, 0x1f3: 0x0004, 0x1f4: 0x0004, 0x1f5: 0x0004, - 0x1f6: 0x0004, 0x1f7: 0x0004, 0x1f8: 0x0004, 0x1f9: 0x0004, 0x1fa: 0x0004, 0x1fb: 0x0004, - 0x1fc: 0x0004, 0x1fd: 0x0004, 0x1ff: 0x0004, + 0x1d1: 0x0024, + 0x1d2: 0x0024, 0x1d3: 0x0024, 0x1d4: 0x0024, 0x1d5: 0x0024, 0x1d6: 0x0024, 0x1d7: 0x0024, + 0x1d8: 0x0024, 0x1d9: 0x0024, 0x1da: 0x0024, 0x1db: 0x0024, 0x1dc: 0x0024, 0x1dd: 0x0024, + 0x1de: 0x0024, 0x1df: 0x0024, 0x1e0: 0x0024, 0x1e1: 0x0024, 0x1e2: 0x0024, 0x1e3: 0x0024, + 0x1e4: 0x0024, 0x1e5: 0x0024, 0x1e6: 0x0024, 0x1e7: 0x0024, 0x1e8: 0x0024, 0x1e9: 0x0024, + 0x1ea: 0x0024, 0x1eb: 0x0024, 0x1ec: 0x0024, 0x1ed: 0x0024, 0x1ee: 0x0024, 0x1ef: 0x0024, + 0x1f0: 0x0024, 0x1f1: 0x0024, 0x1f2: 0x0024, 0x1f3: 0x0024, 0x1f4: 0x0024, 0x1f5: 0x0024, + 0x1f6: 0x0024, 0x1f7: 0x0024, 0x1f8: 0x0024, 0x1f9: 0x0024, 0x1fa: 0x0024, 0x1fb: 0x0024, + 0x1fc: 0x0024, 0x1fd: 0x0024, 0x1ff: 0x0024, // Block 0x8, offset 0x200 - 0x201: 0x0004, 0x202: 0x0004, 0x204: 0x0004, 0x205: 0x0004, - 0x207: 0x0004, + 0x201: 0x0024, 0x202: 0x0024, 0x204: 0x0024, 0x205: 0x0024, + 0x207: 0x0024, // Block 0x9, offset 0x240 - 0x240: 0x0100, 0x241: 0x0100, 0x242: 0x0100, 0x243: 0x0100, 0x244: 0x0100, 0x245: 0x0100, - 0x250: 0x0004, 0x251: 0x0004, - 0x252: 0x0004, 0x253: 0x0004, 0x254: 0x0004, 0x255: 0x0004, 0x256: 0x0004, 0x257: 0x0004, - 0x258: 0x0004, 0x259: 0x0004, 0x25a: 0x0004, 0x25c: 0x0002, + 0x240: 0x0800, 0x241: 0x0800, 0x242: 0x0800, 0x243: 0x0800, 0x244: 0x0800, 0x245: 0x0800, + 0x250: 0x0024, 0x251: 0x0024, + 0x252: 0x0024, 0x253: 0x0024, 0x254: 0x0024, 0x255: 0x0024, 0x256: 0x0024, 0x257: 0x0024, + 0x258: 0x0024, 0x259: 0x0024, 0x25a: 0x0024, 0x25c: 0x0002, // Block 0xa, offset 0x280 - 0x28b: 0x0004, - 0x28c: 0x0004, 0x28d: 0x0004, 0x28e: 0x0004, 0x28f: 0x0004, 0x290: 0x0004, 0x291: 0x0004, - 0x292: 0x0004, 0x293: 0x0004, 0x294: 0x0004, 0x295: 0x0004, 0x296: 0x0004, 0x297: 0x0004, - 0x298: 0x0004, 0x299: 0x0004, 0x29a: 0x0004, 0x29b: 0x0004, 0x29c: 0x0004, 0x29d: 0x0004, - 0x29e: 0x0004, 0x29f: 0x0004, - 0x2b0: 0x0004, + 0x28b: 0x0024, + 0x28c: 0x0024, 0x28d: 0x0024, 0x28e: 0x0024, 0x28f: 0x0024, 0x290: 0x0024, 0x291: 0x0024, + 0x292: 0x0024, 0x293: 0x0024, 0x294: 0x0024, 0x295: 0x0024, 0x296: 0x0024, 0x297: 0x0024, + 0x298: 0x0024, 0x299: 0x0024, 0x29a: 0x0024, 0x29b: 0x0024, 0x29c: 0x0024, 0x29d: 0x0024, + 0x29e: 0x0024, 0x29f: 0x0024, + 0x2b0: 0x0024, // Block 0xb, offset 0x2c0 - 0x2d6: 0x0004, 0x2d7: 0x0004, - 0x2d8: 0x0004, 0x2d9: 0x0004, 0x2da: 0x0004, 0x2db: 0x0004, 0x2dc: 0x0004, 0x2dd: 0x0100, - 0x2df: 0x0004, 0x2e0: 0x0004, 0x2e1: 0x0004, 0x2e2: 0x0004, 0x2e3: 0x0004, - 0x2e4: 0x0004, 0x2e7: 0x0004, 0x2e8: 0x0004, - 0x2ea: 0x0004, 0x2eb: 0x0004, 0x2ec: 0x0004, 0x2ed: 0x0004, + 0x2d6: 0x0024, 0x2d7: 0x0024, + 0x2d8: 0x0024, 0x2d9: 0x0024, 0x2da: 0x0024, 0x2db: 0x0024, 0x2dc: 0x0024, 0x2dd: 0x0800, + 0x2df: 0x0024, 0x2e0: 0x0024, 0x2e1: 0x0024, 0x2e2: 0x0024, 0x2e3: 0x0024, + 0x2e4: 0x0024, 0x2e7: 0x0024, 0x2e8: 0x0024, + 0x2ea: 0x0024, 0x2eb: 0x0024, 0x2ec: 0x0024, 0x2ed: 0x0024, // Block 0xc, offset 0x300 - 0x30f: 0x0100, 0x311: 0x0004, - 0x330: 0x0004, 0x331: 0x0004, 0x332: 0x0004, 0x333: 0x0004, 0x334: 0x0004, 0x335: 0x0004, - 0x336: 0x0004, 0x337: 0x0004, 0x338: 0x0004, 0x339: 0x0004, 0x33a: 0x0004, 0x33b: 0x0004, - 0x33c: 0x0004, 0x33d: 0x0004, 0x33e: 0x0004, 0x33f: 0x0004, + 0x30f: 0x0800, 0x311: 0x0024, + 0x330: 0x0024, 0x331: 0x0024, 0x332: 0x0024, 0x333: 0x0024, 0x334: 0x0024, 0x335: 0x0024, + 0x336: 0x0024, 0x337: 0x0024, 0x338: 0x0024, 0x339: 0x0024, 0x33a: 0x0024, 0x33b: 0x0024, + 0x33c: 0x0024, 0x33d: 0x0024, 0x33e: 0x0024, 0x33f: 0x0024, // Block 0xd, offset 0x340 - 0x340: 0x0004, 0x341: 0x0004, 0x342: 0x0004, 0x343: 0x0004, 0x344: 0x0004, 0x345: 0x0004, - 0x346: 0x0004, 0x347: 0x0004, 0x348: 0x0004, 0x349: 0x0004, 0x34a: 0x0004, + 0x340: 0x0024, 0x341: 0x0024, 0x342: 0x0024, 0x343: 0x0024, 0x344: 0x0024, 0x345: 0x0024, + 0x346: 0x0024, 0x347: 0x0024, 0x348: 0x0024, 0x349: 0x0024, 0x34a: 0x0024, // Block 0xe, offset 0x380 - 0x3a6: 0x0004, 0x3a7: 0x0004, 0x3a8: 0x0004, 0x3a9: 0x0004, - 0x3aa: 0x0004, 0x3ab: 0x0004, 0x3ac: 0x0004, 0x3ad: 0x0004, 0x3ae: 0x0004, 0x3af: 0x0004, - 0x3b0: 0x0004, + 0x3a6: 0x0024, 0x3a7: 0x0024, 0x3a8: 0x0024, 0x3a9: 0x0024, + 0x3aa: 0x0024, 0x3ab: 0x0024, 0x3ac: 0x0024, 0x3ad: 0x0024, 0x3ae: 0x0024, 0x3af: 0x0024, + 0x3b0: 0x0024, // Block 0xf, offset 0x3c0 - 0x3eb: 0x0004, 0x3ec: 0x0004, 0x3ed: 0x0004, 0x3ee: 0x0004, 0x3ef: 0x0004, - 0x3f0: 0x0004, 0x3f1: 0x0004, 0x3f2: 0x0004, 0x3f3: 0x0004, - 0x3fd: 0x0004, + 0x3eb: 0x0024, 0x3ec: 0x0024, 0x3ed: 0x0024, 0x3ee: 0x0024, 0x3ef: 0x0024, + 0x3f0: 0x0024, 0x3f1: 0x0024, 0x3f2: 0x0024, 0x3f3: 0x0024, + 0x3fd: 0x0024, // Block 0x10, offset 0x400 - 0x416: 0x0004, 0x417: 0x0004, - 0x418: 0x0004, 0x419: 0x0004, 0x41b: 0x0004, 0x41c: 0x0004, 0x41d: 0x0004, - 0x41e: 0x0004, 0x41f: 0x0004, 0x420: 0x0004, 0x421: 0x0004, 0x422: 0x0004, 0x423: 0x0004, - 0x425: 0x0004, 0x426: 0x0004, 0x427: 0x0004, 0x429: 0x0004, - 0x42a: 0x0004, 0x42b: 0x0004, 0x42c: 0x0004, 0x42d: 0x0004, + 0x416: 0x0024, 0x417: 0x0024, + 0x418: 0x0024, 0x419: 0x0024, 0x41b: 0x0024, 0x41c: 0x0024, 0x41d: 0x0024, + 0x41e: 0x0024, 0x41f: 0x0024, 0x420: 0x0024, 0x421: 0x0024, 0x422: 0x0024, 0x423: 0x0024, + 0x425: 0x0024, 0x426: 0x0024, 0x427: 0x0024, 0x429: 0x0024, + 0x42a: 0x0024, 0x42b: 0x0024, 0x42c: 0x0024, 0x42d: 0x0024, // Block 0x11, offset 0x440 - 0x459: 0x0004, 0x45a: 0x0004, 0x45b: 0x0004, + 0x459: 0x0024, 0x45a: 0x0024, 0x45b: 0x0024, // Block 0x12, offset 0x480 - 0x490: 0x0100, 0x491: 0x0100, - 0x498: 0x0004, 0x499: 0x0004, 0x49a: 0x0004, 0x49b: 0x0004, 0x49c: 0x0004, 0x49d: 0x0004, - 0x49e: 0x0004, 0x49f: 0x0004, + 0x490: 0x0800, 0x491: 0x0800, + 0x497: 0x0024, + 0x498: 0x0024, 0x499: 0x0024, 0x49a: 0x0024, 0x49b: 0x0024, 0x49c: 0x0024, 0x49d: 0x0024, + 0x49e: 0x0024, 0x49f: 0x0024, // Block 0x13, offset 0x4c0 - 0x4ca: 0x0004, 0x4cb: 0x0004, - 0x4cc: 0x0004, 0x4cd: 0x0004, 0x4ce: 0x0004, 0x4cf: 0x0004, 0x4d0: 0x0004, 0x4d1: 0x0004, - 0x4d2: 0x0004, 0x4d3: 0x0004, 0x4d4: 0x0004, 0x4d5: 0x0004, 0x4d6: 0x0004, 0x4d7: 0x0004, - 0x4d8: 0x0004, 0x4d9: 0x0004, 0x4da: 0x0004, 0x4db: 0x0004, 0x4dc: 0x0004, 0x4dd: 0x0004, - 0x4de: 0x0004, 0x4df: 0x0004, 0x4e0: 0x0004, 0x4e1: 0x0004, 0x4e2: 0x0100, 0x4e3: 0x0004, - 0x4e4: 0x0004, 0x4e5: 0x0004, 0x4e6: 0x0004, 0x4e7: 0x0004, 0x4e8: 0x0004, 0x4e9: 0x0004, - 0x4ea: 0x0004, 0x4eb: 0x0004, 0x4ec: 0x0004, 0x4ed: 0x0004, 0x4ee: 0x0004, 0x4ef: 0x0004, - 0x4f0: 0x0004, 0x4f1: 0x0004, 0x4f2: 0x0004, 0x4f3: 0x0004, 0x4f4: 0x0004, 0x4f5: 0x0004, - 0x4f6: 0x0004, 0x4f7: 0x0004, 0x4f8: 0x0004, 0x4f9: 0x0004, 0x4fa: 0x0004, 0x4fb: 0x0004, - 0x4fc: 0x0004, 0x4fd: 0x0004, 0x4fe: 0x0004, 0x4ff: 0x0004, + 0x4ca: 0x0024, 0x4cb: 0x0024, + 0x4cc: 0x0024, 0x4cd: 0x0024, 0x4ce: 0x0024, 0x4cf: 0x0024, 0x4d0: 0x0024, 0x4d1: 0x0024, + 0x4d2: 0x0024, 0x4d3: 0x0024, 0x4d4: 0x0024, 0x4d5: 0x0024, 0x4d6: 0x0024, 0x4d7: 0x0024, + 0x4d8: 0x0024, 0x4d9: 0x0024, 0x4da: 0x0024, 0x4db: 0x0024, 0x4dc: 0x0024, 0x4dd: 0x0024, + 0x4de: 0x0024, 0x4df: 0x0024, 0x4e0: 0x0024, 0x4e1: 0x0024, 0x4e2: 0x0800, 0x4e3: 0x0024, + 0x4e4: 0x0024, 0x4e5: 0x0024, 0x4e6: 0x0024, 0x4e7: 0x0024, 0x4e8: 0x0024, 0x4e9: 0x0024, + 0x4ea: 0x0024, 0x4eb: 0x0024, 0x4ec: 0x0024, 0x4ed: 0x0024, 0x4ee: 0x0024, 0x4ef: 0x0024, + 0x4f0: 0x0024, 0x4f1: 0x0024, 0x4f2: 0x0024, 0x4f3: 0x0024, 0x4f4: 0x0024, 0x4f5: 0x0024, + 0x4f6: 0x0024, 0x4f7: 0x0024, 0x4f8: 0x0024, 0x4f9: 0x0024, 0x4fa: 0x0024, 0x4fb: 0x0024, + 0x4fc: 0x0024, 0x4fd: 0x0024, 0x4fe: 0x0024, 0x4ff: 0x0024, // Block 0x14, offset 0x500 - 0x500: 0x0004, 0x501: 0x0004, 0x502: 0x0004, 0x503: 0x0400, - 0x53a: 0x0004, 0x53b: 0x0400, - 0x53c: 0x0004, 0x53e: 0x0400, 0x53f: 0x0400, + 0x500: 0x0024, 0x501: 0x0024, 0x502: 0x0024, 0x503: 0x2000, + 0x515: 0x0010, 0x516: 0x0010, 0x517: 0x0010, + 0x518: 0x0010, 0x519: 0x0010, 0x51a: 0x0010, 0x51b: 0x0010, 0x51c: 0x0010, 0x51d: 0x0010, + 0x51e: 0x0010, 0x51f: 0x0010, 0x520: 0x0010, 0x521: 0x0010, 0x522: 0x0010, 0x523: 0x0010, + 0x524: 0x0010, 0x525: 0x0010, 0x526: 0x0010, 0x527: 0x0010, 0x528: 0x0010, 0x529: 0x0010, + 0x52a: 0x0010, 0x52b: 0x0010, 0x52c: 0x0010, 0x52d: 0x0010, 0x52e: 0x0010, 0x52f: 0x0010, + 0x530: 0x0010, 0x531: 0x0010, 0x532: 0x0010, 0x533: 0x0010, 0x534: 0x0010, 0x535: 0x0010, + 0x536: 0x0010, 0x537: 0x0010, 0x538: 0x0010, 0x539: 0x0010, 0x53a: 0x0024, 0x53b: 0x2000, + 0x53c: 0x0024, 0x53e: 0x2000, 0x53f: 0x2000, // Block 0x15, offset 0x540 - 0x540: 0x0400, 0x541: 0x0004, 0x542: 0x0004, 0x543: 0x0004, 0x544: 0x0004, 0x545: 0x0004, - 0x546: 0x0004, 0x547: 0x0004, 0x548: 0x0004, 0x549: 0x0400, 0x54a: 0x0400, 0x54b: 0x0400, - 0x54c: 0x0400, 0x54d: 0x0004, 0x54e: 0x0400, 0x54f: 0x0400, 0x551: 0x0004, - 0x552: 0x0004, 0x553: 0x0004, 0x554: 0x0004, 0x555: 0x0004, 0x556: 0x0004, 0x557: 0x0004, - 0x562: 0x0004, 0x563: 0x0004, + 0x540: 0x2000, 0x541: 0x0024, 0x542: 0x0024, 0x543: 0x0024, 0x544: 0x0024, 0x545: 0x0024, + 0x546: 0x0024, 0x547: 0x0024, 0x548: 0x0024, 0x549: 0x2000, 0x54a: 0x2000, 0x54b: 0x2000, + 0x54c: 0x2000, 0x54d: 0x0044, 0x54e: 0x2000, 0x54f: 0x2000, 0x551: 0x0024, + 0x552: 0x0024, 0x553: 0x0024, 0x554: 0x0024, 0x555: 0x0024, 0x556: 0x0024, 0x557: 0x0024, + 0x558: 0x0010, 0x559: 0x0010, 0x55a: 0x0010, 0x55b: 0x0010, 0x55c: 0x0010, 0x55d: 0x0010, + 0x55e: 0x0010, 0x55f: 0x0010, 0x562: 0x0024, 0x563: 0x0024, + 0x578: 0x0010, 0x579: 0x0010, 0x57a: 0x0010, 0x57b: 0x0010, + 0x57c: 0x0010, 0x57d: 0x0010, 0x57e: 0x0010, 0x57f: 0x0010, // Block 0x16, offset 0x580 - 0x581: 0x0004, 0x582: 0x0400, 0x583: 0x0400, - 0x5bc: 0x0004, 0x5be: 0x0004, 0x5bf: 0x0400, + 0x581: 0x0024, 0x582: 0x2000, 0x583: 0x2000, + 0x595: 0x0010, 0x596: 0x0010, 0x597: 0x0010, + 0x598: 0x0010, 0x599: 0x0010, 0x59a: 0x0010, 0x59b: 0x0010, 0x59c: 0x0010, 0x59d: 0x0010, + 0x59e: 0x0010, 0x59f: 0x0010, 0x5a0: 0x0010, 0x5a1: 0x0010, 0x5a2: 0x0010, 0x5a3: 0x0010, + 0x5a4: 0x0010, 0x5a5: 0x0010, 0x5a6: 0x0010, 0x5a7: 0x0010, 0x5a8: 0x0010, + 0x5aa: 0x0010, 0x5ab: 0x0010, 0x5ac: 0x0010, 0x5ad: 0x0010, 0x5ae: 0x0010, 0x5af: 0x0010, + 0x5b0: 0x0010, 0x5b2: 0x0010, + 0x5b6: 0x0010, 0x5b7: 0x0010, 0x5b8: 0x0010, 0x5b9: 0x0010, + 0x5bc: 0x0024, 0x5be: 0x0024, 0x5bf: 0x2000, // Block 0x17, offset 0x5c0 - 0x5c0: 0x0400, 0x5c1: 0x0004, 0x5c2: 0x0004, 0x5c3: 0x0004, 0x5c4: 0x0004, - 0x5c7: 0x0400, 0x5c8: 0x0400, 0x5cb: 0x0400, - 0x5cc: 0x0400, 0x5cd: 0x0004, - 0x5d7: 0x0004, - 0x5e2: 0x0004, 0x5e3: 0x0004, - 0x5fe: 0x0004, + 0x5c0: 0x2000, 0x5c1: 0x0024, 0x5c2: 0x0024, 0x5c3: 0x0024, 0x5c4: 0x0024, + 0x5c7: 0x2000, 0x5c8: 0x2000, 0x5cb: 0x2000, + 0x5cc: 0x2000, 0x5cd: 0x0044, + 0x5d7: 0x0024, + 0x5dc: 0x0010, 0x5dd: 0x0010, + 0x5df: 0x0010, 0x5e2: 0x0024, 0x5e3: 0x0024, + 0x5f0: 0x0010, 0x5f1: 0x0010, + 0x5fe: 0x0024, // Block 0x18, offset 0x600 - 0x601: 0x0004, 0x602: 0x0004, 0x603: 0x0400, - 0x63c: 0x0004, 0x63e: 0x0400, 0x63f: 0x0400, + 0x601: 0x0024, 0x602: 0x0024, 0x603: 0x2000, + 0x63c: 0x0024, 0x63e: 0x2000, 0x63f: 0x2000, // Block 0x19, offset 0x640 - 0x640: 0x0400, 0x641: 0x0004, 0x642: 0x0004, - 0x647: 0x0004, 0x648: 0x0004, 0x64b: 0x0004, - 0x64c: 0x0004, 0x64d: 0x0004, 0x651: 0x0004, - 0x670: 0x0004, 0x671: 0x0004, 0x675: 0x0004, + 0x640: 0x2000, 0x641: 0x0024, 0x642: 0x0024, + 0x647: 0x0024, 0x648: 0x0024, 0x64b: 0x0024, + 0x64c: 0x0024, 0x64d: 0x0024, 0x651: 0x0024, + 0x670: 0x0024, 0x671: 0x0024, 0x675: 0x0024, // Block 0x1a, offset 0x680 - 0x680: 0x0400, 0x681: 0x0004, 0x682: 0x0004, 0x683: 0x0004, 0x684: 0x0004, 0x685: 0x0004, - 0x687: 0x0004, 0x688: 0x0004, 0x689: 0x0400, 0x68b: 0x0400, - 0x68c: 0x0400, 0x68d: 0x0004, - 0x6a2: 0x0004, 0x6a3: 0x0004, - 0x6ba: 0x0004, 0x6bb: 0x0004, - 0x6bc: 0x0004, 0x6bd: 0x0004, 0x6be: 0x0004, 0x6bf: 0x0004, + 0x681: 0x0024, 0x682: 0x0024, 0x683: 0x2000, + 0x695: 0x0010, 0x696: 0x0010, 0x697: 0x0010, + 0x698: 0x0010, 0x699: 0x0010, 0x69a: 0x0010, 0x69b: 0x0010, 0x69c: 0x0010, 0x69d: 0x0010, + 0x69e: 0x0010, 0x69f: 0x0010, 0x6a0: 0x0010, 0x6a1: 0x0010, 0x6a2: 0x0010, 0x6a3: 0x0010, + 0x6a4: 0x0010, 0x6a5: 0x0010, 0x6a6: 0x0010, 0x6a7: 0x0010, 0x6a8: 0x0010, + 0x6aa: 0x0010, 0x6ab: 0x0010, 0x6ac: 0x0010, 0x6ad: 0x0010, 0x6ae: 0x0010, 0x6af: 0x0010, + 0x6b0: 0x0010, 0x6b2: 0x0010, 0x6b3: 0x0010, 0x6b5: 0x0010, + 0x6b6: 0x0010, 0x6b7: 0x0010, 0x6b8: 0x0010, 0x6b9: 0x0010, + 0x6bc: 0x0024, 0x6be: 0x2000, 0x6bf: 0x2000, // Block 0x1b, offset 0x6c0 - 0x6c1: 0x0004, 0x6c2: 0x0400, 0x6c3: 0x0400, - 0x6fc: 0x0004, 0x6fe: 0x0004, 0x6ff: 0x0004, + 0x6c0: 0x2000, 0x6c1: 0x0024, 0x6c2: 0x0024, 0x6c3: 0x0024, 0x6c4: 0x0024, 0x6c5: 0x0024, + 0x6c7: 0x0024, 0x6c8: 0x0024, 0x6c9: 0x2000, 0x6cb: 0x2000, + 0x6cc: 0x2000, 0x6cd: 0x0044, + 0x6e2: 0x0024, 0x6e3: 0x0024, + 0x6f9: 0x0010, 0x6fa: 0x0024, 0x6fb: 0x0024, + 0x6fc: 0x0024, 0x6fd: 0x0024, 0x6fe: 0x0024, 0x6ff: 0x0024, // Block 0x1c, offset 0x700 - 0x700: 0x0400, 0x701: 0x0004, 0x702: 0x0004, 0x703: 0x0004, 0x704: 0x0004, - 0x707: 0x0400, 0x708: 0x0400, 0x70b: 0x0400, - 0x70c: 0x0400, 0x70d: 0x0004, - 0x715: 0x0004, 0x716: 0x0004, 0x717: 0x0004, - 0x722: 0x0004, 0x723: 0x0004, + 0x701: 0x0024, 0x702: 0x2000, 0x703: 0x2000, + 0x715: 0x0010, 0x716: 0x0010, 0x717: 0x0010, + 0x718: 0x0010, 0x719: 0x0010, 0x71a: 0x0010, 0x71b: 0x0010, 0x71c: 0x0010, 0x71d: 0x0010, + 0x71e: 0x0010, 0x71f: 0x0010, 0x720: 0x0010, 0x721: 0x0010, 0x722: 0x0010, 0x723: 0x0010, + 0x724: 0x0010, 0x725: 0x0010, 0x726: 0x0010, 0x727: 0x0010, 0x728: 0x0010, + 0x72a: 0x0010, 0x72b: 0x0010, 0x72c: 0x0010, 0x72d: 0x0010, 0x72e: 0x0010, 0x72f: 0x0010, + 0x730: 0x0010, 0x732: 0x0010, 0x733: 0x0010, 0x735: 0x0010, + 0x736: 0x0010, 0x737: 0x0010, 0x738: 0x0010, 0x739: 0x0010, + 0x73c: 0x0024, 0x73e: 0x0024, 0x73f: 0x0024, // Block 0x1d, offset 0x740 - 0x742: 0x0004, - 0x77e: 0x0004, 0x77f: 0x0400, + 0x740: 0x2000, 0x741: 0x0024, 0x742: 0x0024, 0x743: 0x0024, 0x744: 0x0024, + 0x747: 0x2000, 0x748: 0x2000, 0x74b: 0x2000, + 0x74c: 0x2000, 0x74d: 0x0044, + 0x755: 0x0024, 0x756: 0x0024, 0x757: 0x0024, + 0x75c: 0x0010, 0x75d: 0x0010, + 0x75f: 0x0010, 0x762: 0x0024, 0x763: 0x0024, + 0x771: 0x0010, // Block 0x1e, offset 0x780 - 0x780: 0x0004, 0x781: 0x0400, 0x782: 0x0400, - 0x786: 0x0400, 0x787: 0x0400, 0x788: 0x0400, 0x78a: 0x0400, 0x78b: 0x0400, - 0x78c: 0x0400, 0x78d: 0x0004, - 0x797: 0x0004, + 0x782: 0x0024, + 0x7be: 0x0024, 0x7bf: 0x2000, // Block 0x1f, offset 0x7c0 - 0x7c0: 0x0004, 0x7c1: 0x0400, 0x7c2: 0x0400, 0x7c3: 0x0400, 0x7c4: 0x0004, - 0x7fc: 0x0004, 0x7fe: 0x0004, 0x7ff: 0x0004, + 0x7c0: 0x0024, 0x7c1: 0x2000, 0x7c2: 0x2000, + 0x7c6: 0x2000, 0x7c7: 0x2000, 0x7c8: 0x2000, 0x7ca: 0x2000, 0x7cb: 0x2000, + 0x7cc: 0x2000, 0x7cd: 0x0024, + 0x7d7: 0x0024, // Block 0x20, offset 0x800 - 0x800: 0x0004, 0x801: 0x0400, 0x802: 0x0400, 0x803: 0x0400, 0x804: 0x0400, - 0x806: 0x0004, 0x807: 0x0004, 0x808: 0x0004, 0x80a: 0x0004, 0x80b: 0x0004, - 0x80c: 0x0004, 0x80d: 0x0004, - 0x815: 0x0004, 0x816: 0x0004, - 0x822: 0x0004, 0x823: 0x0004, + 0x800: 0x0024, 0x801: 0x2000, 0x802: 0x2000, 0x803: 0x2000, 0x804: 0x0024, + 0x815: 0x0010, 0x816: 0x0010, 0x817: 0x0010, + 0x818: 0x0010, 0x819: 0x0010, 0x81a: 0x0010, 0x81b: 0x0010, 0x81c: 0x0010, 0x81d: 0x0010, + 0x81e: 0x0010, 0x81f: 0x0010, 0x820: 0x0010, 0x821: 0x0010, 0x822: 0x0010, 0x823: 0x0010, + 0x824: 0x0010, 0x825: 0x0010, 0x826: 0x0010, 0x827: 0x0010, 0x828: 0x0010, + 0x82a: 0x0010, 0x82b: 0x0010, 0x82c: 0x0010, 0x82d: 0x0010, 0x82e: 0x0010, 0x82f: 0x0010, + 0x830: 0x0010, 0x831: 0x0010, 0x832: 0x0010, 0x833: 0x0010, 0x834: 0x0010, 0x835: 0x0010, + 0x836: 0x0010, 0x837: 0x0010, 0x838: 0x0010, 0x839: 0x0010, + 0x83c: 0x0024, 0x83e: 0x0024, 0x83f: 0x0024, // Block 0x21, offset 0x840 - 0x841: 0x0004, 0x842: 0x0400, 0x843: 0x0400, - 0x87c: 0x0004, 0x87e: 0x0400, 0x87f: 0x0004, + 0x840: 0x0024, 0x841: 0x2000, 0x842: 0x2000, 0x843: 0x2000, 0x844: 0x2000, + 0x846: 0x0024, 0x847: 0x0024, 0x848: 0x0024, 0x84a: 0x0024, 0x84b: 0x0024, + 0x84c: 0x0024, 0x84d: 0x0044, + 0x855: 0x0024, 0x856: 0x0024, + 0x858: 0x0010, 0x859: 0x0010, 0x85a: 0x0010, + 0x862: 0x0024, 0x863: 0x0024, // Block 0x22, offset 0x880 - 0x880: 0x0400, 0x881: 0x0400, 0x882: 0x0004, 0x883: 0x0400, 0x884: 0x0400, - 0x886: 0x0004, 0x887: 0x0400, 0x888: 0x0400, 0x88a: 0x0400, 0x88b: 0x0400, - 0x88c: 0x0004, 0x88d: 0x0004, - 0x895: 0x0004, 0x896: 0x0004, - 0x8a2: 0x0004, 0x8a3: 0x0004, - 0x8b3: 0x0400, + 0x881: 0x0024, 0x882: 0x2000, 0x883: 0x2000, + 0x8bc: 0x0024, 0x8be: 0x2000, 0x8bf: 0x0024, // Block 0x23, offset 0x8c0 - 0x8c0: 0x0004, 0x8c1: 0x0004, 0x8c2: 0x0400, 0x8c3: 0x0400, - 0x8fb: 0x0004, - 0x8fc: 0x0004, 0x8fe: 0x0004, 0x8ff: 0x0400, + 0x8c0: 0x0024, 0x8c1: 0x2000, 0x8c2: 0x0024, 0x8c3: 0x2000, 0x8c4: 0x2000, + 0x8c6: 0x0024, 0x8c7: 0x0024, 0x8c8: 0x0024, 0x8ca: 0x0024, 0x8cb: 0x0024, + 0x8cc: 0x0024, 0x8cd: 0x0024, + 0x8d5: 0x0024, 0x8d6: 0x0024, + 0x8e2: 0x0024, 0x8e3: 0x0024, + 0x8f3: 0x2000, // Block 0x24, offset 0x900 - 0x900: 0x0400, 0x901: 0x0004, 0x902: 0x0004, 0x903: 0x0004, 0x904: 0x0004, - 0x906: 0x0400, 0x907: 0x0400, 0x908: 0x0400, 0x90a: 0x0400, 0x90b: 0x0400, - 0x90c: 0x0400, 0x90d: 0x0004, 0x90e: 0x0100, - 0x917: 0x0004, - 0x922: 0x0004, 0x923: 0x0004, + 0x900: 0x0024, 0x901: 0x0024, 0x902: 0x2000, 0x903: 0x2000, + 0x915: 0x0010, 0x916: 0x0010, 0x917: 0x0010, + 0x918: 0x0010, 0x919: 0x0010, 0x91a: 0x0010, 0x91b: 0x0010, 0x91c: 0x0010, 0x91d: 0x0010, + 0x91e: 0x0010, 0x91f: 0x0010, 0x920: 0x0010, 0x921: 0x0010, 0x922: 0x0010, 0x923: 0x0010, + 0x924: 0x0010, 0x925: 0x0010, 0x926: 0x0010, 0x927: 0x0010, 0x928: 0x0010, 0x929: 0x0010, + 0x92a: 0x0010, 0x92b: 0x0010, 0x92c: 0x0010, 0x92d: 0x0010, 0x92e: 0x0010, 0x92f: 0x0010, + 0x930: 0x0010, 0x931: 0x0010, 0x932: 0x0010, 0x933: 0x0010, 0x934: 0x0010, 0x935: 0x0010, + 0x936: 0x0010, 0x937: 0x0010, 0x938: 0x0010, 0x939: 0x0010, 0x93a: 0x0010, 0x93b: 0x0024, + 0x93c: 0x0024, 0x93e: 0x0024, 0x93f: 0x2000, // Block 0x25, offset 0x940 - 0x941: 0x0004, 0x942: 0x0400, 0x943: 0x0400, + 0x940: 0x2000, 0x941: 0x0024, 0x942: 0x0024, 0x943: 0x0024, 0x944: 0x0024, + 0x946: 0x2000, 0x947: 0x2000, 0x948: 0x2000, 0x94a: 0x2000, 0x94b: 0x2000, + 0x94c: 0x2000, 0x94d: 0x0044, 0x94e: 0x0800, + 0x957: 0x0024, + 0x962: 0x0024, 0x963: 0x0024, // Block 0x26, offset 0x980 - 0x98a: 0x0004, - 0x98f: 0x0004, 0x990: 0x0400, 0x991: 0x0400, - 0x992: 0x0004, 0x993: 0x0004, 0x994: 0x0004, 0x996: 0x0004, - 0x998: 0x0400, 0x999: 0x0400, 0x99a: 0x0400, 0x99b: 0x0400, 0x99c: 0x0400, 0x99d: 0x0400, - 0x99e: 0x0400, 0x99f: 0x0004, - 0x9b2: 0x0400, 0x9b3: 0x0400, + 0x981: 0x0024, 0x982: 0x2000, 0x983: 0x2000, // Block 0x27, offset 0x9c0 - 0x9f1: 0x0004, 0x9f3: 0x0400, 0x9f4: 0x0004, 0x9f5: 0x0004, - 0x9f6: 0x0004, 0x9f7: 0x0004, 0x9f8: 0x0004, 0x9f9: 0x0004, 0x9fa: 0x0004, + 0x9ca: 0x0024, + 0x9cf: 0x0024, 0x9d0: 0x2000, 0x9d1: 0x2000, + 0x9d2: 0x0024, 0x9d3: 0x0024, 0x9d4: 0x0024, 0x9d6: 0x0024, + 0x9d8: 0x2000, 0x9d9: 0x2000, 0x9da: 0x2000, 0x9db: 0x2000, 0x9dc: 0x2000, 0x9dd: 0x2000, + 0x9de: 0x2000, 0x9df: 0x0024, + 0x9f2: 0x2000, 0x9f3: 0x2000, // Block 0x28, offset 0xa00 - 0xa07: 0x0004, 0xa08: 0x0004, 0xa09: 0x0004, 0xa0a: 0x0004, 0xa0b: 0x0004, - 0xa0c: 0x0004, 0xa0d: 0x0004, 0xa0e: 0x0004, + 0xa31: 0x0024, 0xa33: 0x2000, 0xa34: 0x0024, 0xa35: 0x0024, + 0xa36: 0x0024, 0xa37: 0x0024, 0xa38: 0x0024, 0xa39: 0x0024, 0xa3a: 0x0024, // Block 0x29, offset 0xa40 - 0xa71: 0x0004, 0xa73: 0x0400, 0xa74: 0x0004, 0xa75: 0x0004, - 0xa76: 0x0004, 0xa77: 0x0004, 0xa78: 0x0004, 0xa79: 0x0004, 0xa7a: 0x0004, 0xa7b: 0x0004, - 0xa7c: 0x0004, + 0xa47: 0x0024, 0xa48: 0x0024, 0xa49: 0x0024, 0xa4a: 0x0024, 0xa4b: 0x0024, + 0xa4c: 0x0024, 0xa4d: 0x0024, 0xa4e: 0x0024, // Block 0x2a, offset 0xa80 - 0xa88: 0x0004, 0xa89: 0x0004, 0xa8a: 0x0004, 0xa8b: 0x0004, - 0xa8c: 0x0004, 0xa8d: 0x0004, 0xa8e: 0x0004, + 0xab1: 0x0024, 0xab3: 0x2000, 0xab4: 0x0024, 0xab5: 0x0024, + 0xab6: 0x0024, 0xab7: 0x0024, 0xab8: 0x0024, 0xab9: 0x0024, 0xaba: 0x0024, 0xabb: 0x0024, + 0xabc: 0x0024, // Block 0x2b, offset 0xac0 - 0xad8: 0x0004, 0xad9: 0x0004, - 0xaf5: 0x0004, - 0xaf7: 0x0004, 0xaf9: 0x0004, - 0xafe: 0x0400, 0xaff: 0x0400, + 0xac8: 0x0024, 0xac9: 0x0024, 0xaca: 0x0024, 0xacb: 0x0024, + 0xacc: 0x0024, 0xacd: 0x0024, 0xace: 0x0024, // Block 0x2c, offset 0xb00 - 0xb31: 0x0004, 0xb32: 0x0004, 0xb33: 0x0004, 0xb34: 0x0004, 0xb35: 0x0004, - 0xb36: 0x0004, 0xb37: 0x0004, 0xb38: 0x0004, 0xb39: 0x0004, 0xb3a: 0x0004, 0xb3b: 0x0004, - 0xb3c: 0x0004, 0xb3d: 0x0004, 0xb3e: 0x0004, 0xb3f: 0x0400, + 0xb18: 0x0024, 0xb19: 0x0024, + 0xb35: 0x0024, + 0xb37: 0x0024, 0xb39: 0x0024, + 0xb3e: 0x2000, 0xb3f: 0x2000, // Block 0x2d, offset 0xb40 - 0xb40: 0x0004, 0xb41: 0x0004, 0xb42: 0x0004, 0xb43: 0x0004, 0xb44: 0x0004, - 0xb46: 0x0004, 0xb47: 0x0004, - 0xb4d: 0x0004, 0xb4e: 0x0004, 0xb4f: 0x0004, 0xb50: 0x0004, 0xb51: 0x0004, - 0xb52: 0x0004, 0xb53: 0x0004, 0xb54: 0x0004, 0xb55: 0x0004, 0xb56: 0x0004, 0xb57: 0x0004, - 0xb59: 0x0004, 0xb5a: 0x0004, 0xb5b: 0x0004, 0xb5c: 0x0004, 0xb5d: 0x0004, - 0xb5e: 0x0004, 0xb5f: 0x0004, 0xb60: 0x0004, 0xb61: 0x0004, 0xb62: 0x0004, 0xb63: 0x0004, - 0xb64: 0x0004, 0xb65: 0x0004, 0xb66: 0x0004, 0xb67: 0x0004, 0xb68: 0x0004, 0xb69: 0x0004, - 0xb6a: 0x0004, 0xb6b: 0x0004, 0xb6c: 0x0004, 0xb6d: 0x0004, 0xb6e: 0x0004, 0xb6f: 0x0004, - 0xb70: 0x0004, 0xb71: 0x0004, 0xb72: 0x0004, 0xb73: 0x0004, 0xb74: 0x0004, 0xb75: 0x0004, - 0xb76: 0x0004, 0xb77: 0x0004, 0xb78: 0x0004, 0xb79: 0x0004, 0xb7a: 0x0004, 0xb7b: 0x0004, - 0xb7c: 0x0004, + 0xb71: 0x0024, 0xb72: 0x0024, 0xb73: 0x0024, 0xb74: 0x0024, 0xb75: 0x0024, + 0xb76: 0x0024, 0xb77: 0x0024, 0xb78: 0x0024, 0xb79: 0x0024, 0xb7a: 0x0024, 0xb7b: 0x0024, + 0xb7c: 0x0024, 0xb7d: 0x0024, 0xb7e: 0x0024, 0xb7f: 0x2000, // Block 0x2e, offset 0xb80 - 0xb86: 0x0004, + 0xb80: 0x0024, 0xb81: 0x0024, 0xb82: 0x0024, 0xb83: 0x0024, 0xb84: 0x0024, + 0xb86: 0x0024, 0xb87: 0x0024, + 0xb8d: 0x0024, 0xb8e: 0x0024, 0xb8f: 0x0024, 0xb90: 0x0024, 0xb91: 0x0024, + 0xb92: 0x0024, 0xb93: 0x0024, 0xb94: 0x0024, 0xb95: 0x0024, 0xb96: 0x0024, 0xb97: 0x0024, + 0xb99: 0x0024, 0xb9a: 0x0024, 0xb9b: 0x0024, 0xb9c: 0x0024, 0xb9d: 0x0024, + 0xb9e: 0x0024, 0xb9f: 0x0024, 0xba0: 0x0024, 0xba1: 0x0024, 0xba2: 0x0024, 0xba3: 0x0024, + 0xba4: 0x0024, 0xba5: 0x0024, 0xba6: 0x0024, 0xba7: 0x0024, 0xba8: 0x0024, 0xba9: 0x0024, + 0xbaa: 0x0024, 0xbab: 0x0024, 0xbac: 0x0024, 0xbad: 0x0024, 0xbae: 0x0024, 0xbaf: 0x0024, + 0xbb0: 0x0024, 0xbb1: 0x0024, 0xbb2: 0x0024, 0xbb3: 0x0024, 0xbb4: 0x0024, 0xbb5: 0x0024, + 0xbb6: 0x0024, 0xbb7: 0x0024, 0xbb8: 0x0024, 0xbb9: 0x0024, 0xbba: 0x0024, 0xbbb: 0x0024, + 0xbbc: 0x0024, // Block 0x2f, offset 0xbc0 - 0xbed: 0x0004, 0xbee: 0x0004, 0xbef: 0x0004, - 0xbf0: 0x0004, 0xbf1: 0x0400, 0xbf2: 0x0004, 0xbf3: 0x0004, 0xbf4: 0x0004, 0xbf5: 0x0004, - 0xbf6: 0x0004, 0xbf7: 0x0004, 0xbf9: 0x0004, 0xbfa: 0x0004, 0xbfb: 0x0400, - 0xbfc: 0x0400, 0xbfd: 0x0004, 0xbfe: 0x0004, + 0xbc6: 0x0024, // Block 0x30, offset 0xc00 - 0xc16: 0x0400, 0xc17: 0x0400, - 0xc18: 0x0004, 0xc19: 0x0004, - 0xc1e: 0x0004, 0xc1f: 0x0004, 0xc20: 0x0004, - 0xc31: 0x0004, 0xc32: 0x0004, 0xc33: 0x0004, 0xc34: 0x0004, + 0xc00: 0x0010, 0xc01: 0x0010, 0xc02: 0x0010, 0xc03: 0x0010, 0xc04: 0x0010, 0xc05: 0x0010, + 0xc06: 0x0010, 0xc07: 0x0010, 0xc08: 0x0010, 0xc09: 0x0010, 0xc0a: 0x0010, 0xc0b: 0x0010, + 0xc0c: 0x0010, 0xc0d: 0x0010, 0xc0e: 0x0010, 0xc0f: 0x0010, 0xc10: 0x0010, 0xc11: 0x0010, + 0xc12: 0x0010, 0xc13: 0x0010, 0xc14: 0x0010, 0xc15: 0x0010, 0xc16: 0x0010, 0xc17: 0x0010, + 0xc18: 0x0010, 0xc19: 0x0010, 0xc1a: 0x0010, 0xc1b: 0x0010, 0xc1c: 0x0010, 0xc1d: 0x0010, + 0xc1e: 0x0010, 0xc1f: 0x0010, 0xc20: 0x0010, 0xc21: 0x0010, 0xc22: 0x0010, 0xc23: 0x0010, + 0xc24: 0x0010, 0xc25: 0x0010, 0xc26: 0x0010, 0xc27: 0x0010, 0xc28: 0x0010, 0xc29: 0x0010, + 0xc2a: 0x0010, 0xc2d: 0x0024, 0xc2e: 0x0024, 0xc2f: 0x0024, + 0xc30: 0x0024, 0xc31: 0x2000, 0xc32: 0x0024, 0xc33: 0x0024, 0xc34: 0x0024, 0xc35: 0x0024, + 0xc36: 0x0024, 0xc37: 0x0024, 0xc39: 0x0044, 0xc3a: 0x0024, 0xc3b: 0x2000, + 0xc3c: 0x2000, 0xc3d: 0x0024, 0xc3e: 0x0024, 0xc3f: 0x0010, // Block 0x31, offset 0xc40 - 0xc42: 0x0004, 0xc44: 0x0400, 0xc45: 0x0004, - 0xc46: 0x0004, - 0xc4d: 0x0004, - 0xc5d: 0x0004, + 0xc50: 0x0010, 0xc51: 0x0010, + 0xc52: 0x0010, 0xc53: 0x0010, 0xc54: 0x0010, 0xc55: 0x0010, 0xc56: 0x2000, 0xc57: 0x2000, + 0xc58: 0x0024, 0xc59: 0x0024, 0xc5a: 0x0010, 0xc5b: 0x0010, 0xc5c: 0x0010, 0xc5d: 0x0010, + 0xc5e: 0x0024, 0xc5f: 0x0024, 0xc60: 0x0024, 0xc61: 0x0010, + 0xc65: 0x0010, 0xc66: 0x0010, + 0xc6e: 0x0010, 0xc6f: 0x0010, + 0xc70: 0x0010, 0xc71: 0x0024, 0xc72: 0x0024, 0xc73: 0x0024, 0xc74: 0x0024, 0xc75: 0x0010, + 0xc76: 0x0010, 0xc77: 0x0010, 0xc78: 0x0010, 0xc79: 0x0010, 0xc7a: 0x0010, 0xc7b: 0x0010, + 0xc7c: 0x0010, 0xc7d: 0x0010, 0xc7e: 0x0010, 0xc7f: 0x0010, // Block 0x32, offset 0xc80 - 0xc80: 0x0010, 0xc81: 0x0010, 0xc82: 0x0010, 0xc83: 0x0010, 0xc84: 0x0010, 0xc85: 0x0010, - 0xc86: 0x0010, 0xc87: 0x0010, 0xc88: 0x0010, 0xc89: 0x0010, 0xc8a: 0x0010, 0xc8b: 0x0010, - 0xc8c: 0x0010, 0xc8d: 0x0010, 0xc8e: 0x0010, 0xc8f: 0x0010, 0xc90: 0x0010, 0xc91: 0x0010, - 0xc92: 0x0010, 0xc93: 0x0010, 0xc94: 0x0010, 0xc95: 0x0010, 0xc96: 0x0010, 0xc97: 0x0010, - 0xc98: 0x0010, 0xc99: 0x0010, 0xc9a: 0x0010, 0xc9b: 0x0010, 0xc9c: 0x0010, 0xc9d: 0x0010, - 0xc9e: 0x0010, 0xc9f: 0x0010, 0xca0: 0x0010, 0xca1: 0x0010, 0xca2: 0x0010, 0xca3: 0x0010, - 0xca4: 0x0010, 0xca5: 0x0010, 0xca6: 0x0010, 0xca7: 0x0010, 0xca8: 0x0010, 0xca9: 0x0010, - 0xcaa: 0x0010, 0xcab: 0x0010, 0xcac: 0x0010, 0xcad: 0x0010, 0xcae: 0x0010, 0xcaf: 0x0010, - 0xcb0: 0x0010, 0xcb1: 0x0010, 0xcb2: 0x0010, 0xcb3: 0x0010, 0xcb4: 0x0010, 0xcb5: 0x0010, - 0xcb6: 0x0010, 0xcb7: 0x0010, 0xcb8: 0x0010, 0xcb9: 0x0010, 0xcba: 0x0010, 0xcbb: 0x0010, - 0xcbc: 0x0010, 0xcbd: 0x0010, 0xcbe: 0x0010, 0xcbf: 0x0010, + 0xc80: 0x0010, 0xc81: 0x0010, 0xc82: 0x0024, 0xc84: 0x2000, 0xc85: 0x0024, + 0xc86: 0x0024, + 0xc8d: 0x0024, 0xc8e: 0x0010, + 0xc9d: 0x0024, // Block 0x33, offset 0xcc0 - 0xcc0: 0x0010, 0xcc1: 0x0010, 0xcc2: 0x0010, 0xcc3: 0x0010, 0xcc4: 0x0010, 0xcc5: 0x0010, - 0xcc6: 0x0010, 0xcc7: 0x0010, 0xcc8: 0x0010, 0xcc9: 0x0010, 0xcca: 0x0010, 0xccb: 0x0010, - 0xccc: 0x0010, 0xccd: 0x0010, 0xcce: 0x0010, 0xccf: 0x0010, 0xcd0: 0x0010, 0xcd1: 0x0010, - 0xcd2: 0x0010, 0xcd3: 0x0010, 0xcd4: 0x0010, 0xcd5: 0x0010, 0xcd6: 0x0010, 0xcd7: 0x0010, - 0xcd8: 0x0010, 0xcd9: 0x0010, 0xcda: 0x0010, 0xcdb: 0x0010, 0xcdc: 0x0010, 0xcdd: 0x0010, - 0xcde: 0x0010, 0xcdf: 0x0010, 0xce0: 0x1000, 0xce1: 0x1000, 0xce2: 0x1000, 0xce3: 0x1000, - 0xce4: 0x1000, 0xce5: 0x1000, 0xce6: 0x1000, 0xce7: 0x1000, 0xce8: 0x1000, 0xce9: 0x1000, - 0xcea: 0x1000, 0xceb: 0x1000, 0xcec: 0x1000, 0xced: 0x1000, 0xcee: 0x1000, 0xcef: 0x1000, - 0xcf0: 0x1000, 0xcf1: 0x1000, 0xcf2: 0x1000, 0xcf3: 0x1000, 0xcf4: 0x1000, 0xcf5: 0x1000, - 0xcf6: 0x1000, 0xcf7: 0x1000, 0xcf8: 0x1000, 0xcf9: 0x1000, 0xcfa: 0x1000, 0xcfb: 0x1000, - 0xcfc: 0x1000, 0xcfd: 0x1000, 0xcfe: 0x1000, 0xcff: 0x1000, + 0xcc0: 0x0080, 0xcc1: 0x0080, 0xcc2: 0x0080, 0xcc3: 0x0080, 0xcc4: 0x0080, 0xcc5: 0x0080, + 0xcc6: 0x0080, 0xcc7: 0x0080, 0xcc8: 0x0080, 0xcc9: 0x0080, 0xcca: 0x0080, 0xccb: 0x0080, + 0xccc: 0x0080, 0xccd: 0x0080, 0xcce: 0x0080, 0xccf: 0x0080, 0xcd0: 0x0080, 0xcd1: 0x0080, + 0xcd2: 0x0080, 0xcd3: 0x0080, 0xcd4: 0x0080, 0xcd5: 0x0080, 0xcd6: 0x0080, 0xcd7: 0x0080, + 0xcd8: 0x0080, 0xcd9: 0x0080, 0xcda: 0x0080, 0xcdb: 0x0080, 0xcdc: 0x0080, 0xcdd: 0x0080, + 0xcde: 0x0080, 0xcdf: 0x0080, 0xce0: 0x0080, 0xce1: 0x0080, 0xce2: 0x0080, 0xce3: 0x0080, + 0xce4: 0x0080, 0xce5: 0x0080, 0xce6: 0x0080, 0xce7: 0x0080, 0xce8: 0x0080, 0xce9: 0x0080, + 0xcea: 0x0080, 0xceb: 0x0080, 0xcec: 0x0080, 0xced: 0x0080, 0xcee: 0x0080, 0xcef: 0x0080, + 0xcf0: 0x0080, 0xcf1: 0x0080, 0xcf2: 0x0080, 0xcf3: 0x0080, 0xcf4: 0x0080, 0xcf5: 0x0080, + 0xcf6: 0x0080, 0xcf7: 0x0080, 0xcf8: 0x0080, 0xcf9: 0x0080, 0xcfa: 0x0080, 0xcfb: 0x0080, + 0xcfc: 0x0080, 0xcfd: 0x0080, 0xcfe: 0x0080, 0xcff: 0x0080, // Block 0x34, offset 0xd00 - 0xd00: 0x1000, 0xd01: 0x1000, 0xd02: 0x1000, 0xd03: 0x1000, 0xd04: 0x1000, 0xd05: 0x1000, - 0xd06: 0x1000, 0xd07: 0x1000, 0xd08: 0x1000, 0xd09: 0x1000, 0xd0a: 0x1000, 0xd0b: 0x1000, - 0xd0c: 0x1000, 0xd0d: 0x1000, 0xd0e: 0x1000, 0xd0f: 0x1000, 0xd10: 0x1000, 0xd11: 0x1000, - 0xd12: 0x1000, 0xd13: 0x1000, 0xd14: 0x1000, 0xd15: 0x1000, 0xd16: 0x1000, 0xd17: 0x1000, - 0xd18: 0x1000, 0xd19: 0x1000, 0xd1a: 0x1000, 0xd1b: 0x1000, 0xd1c: 0x1000, 0xd1d: 0x1000, - 0xd1e: 0x1000, 0xd1f: 0x1000, 0xd20: 0x1000, 0xd21: 0x1000, 0xd22: 0x1000, 0xd23: 0x1000, - 0xd24: 0x1000, 0xd25: 0x1000, 0xd26: 0x1000, 0xd27: 0x1000, 0xd28: 0x0800, 0xd29: 0x0800, - 0xd2a: 0x0800, 0xd2b: 0x0800, 0xd2c: 0x0800, 0xd2d: 0x0800, 0xd2e: 0x0800, 0xd2f: 0x0800, - 0xd30: 0x0800, 0xd31: 0x0800, 0xd32: 0x0800, 0xd33: 0x0800, 0xd34: 0x0800, 0xd35: 0x0800, - 0xd36: 0x0800, 0xd37: 0x0800, 0xd38: 0x0800, 0xd39: 0x0800, 0xd3a: 0x0800, 0xd3b: 0x0800, - 0xd3c: 0x0800, 0xd3d: 0x0800, 0xd3e: 0x0800, 0xd3f: 0x0800, + 0xd00: 0x0080, 0xd01: 0x0080, 0xd02: 0x0080, 0xd03: 0x0080, 0xd04: 0x0080, 0xd05: 0x0080, + 0xd06: 0x0080, 0xd07: 0x0080, 0xd08: 0x0080, 0xd09: 0x0080, 0xd0a: 0x0080, 0xd0b: 0x0080, + 0xd0c: 0x0080, 0xd0d: 0x0080, 0xd0e: 0x0080, 0xd0f: 0x0080, 0xd10: 0x0080, 0xd11: 0x0080, + 0xd12: 0x0080, 0xd13: 0x0080, 0xd14: 0x0080, 0xd15: 0x0080, 0xd16: 0x0080, 0xd17: 0x0080, + 0xd18: 0x0080, 0xd19: 0x0080, 0xd1a: 0x0080, 0xd1b: 0x0080, 0xd1c: 0x0080, 0xd1d: 0x0080, + 0xd1e: 0x0080, 0xd1f: 0x0080, 0xd20: 0x8000, 0xd21: 0x8000, 0xd22: 0x8000, 0xd23: 0x8000, + 0xd24: 0x8000, 0xd25: 0x8000, 0xd26: 0x8000, 0xd27: 0x8000, 0xd28: 0x8000, 0xd29: 0x8000, + 0xd2a: 0x8000, 0xd2b: 0x8000, 0xd2c: 0x8000, 0xd2d: 0x8000, 0xd2e: 0x8000, 0xd2f: 0x8000, + 0xd30: 0x8000, 0xd31: 0x8000, 0xd32: 0x8000, 0xd33: 0x8000, 0xd34: 0x8000, 0xd35: 0x8000, + 0xd36: 0x8000, 0xd37: 0x8000, 0xd38: 0x8000, 0xd39: 0x8000, 0xd3a: 0x8000, 0xd3b: 0x8000, + 0xd3c: 0x8000, 0xd3d: 0x8000, 0xd3e: 0x8000, 0xd3f: 0x8000, // Block 0x35, offset 0xd40 - 0xd40: 0x0800, 0xd41: 0x0800, 0xd42: 0x0800, 0xd43: 0x0800, 0xd44: 0x0800, 0xd45: 0x0800, - 0xd46: 0x0800, 0xd47: 0x0800, 0xd48: 0x0800, 0xd49: 0x0800, 0xd4a: 0x0800, 0xd4b: 0x0800, - 0xd4c: 0x0800, 0xd4d: 0x0800, 0xd4e: 0x0800, 0xd4f: 0x0800, 0xd50: 0x0800, 0xd51: 0x0800, - 0xd52: 0x0800, 0xd53: 0x0800, 0xd54: 0x0800, 0xd55: 0x0800, 0xd56: 0x0800, 0xd57: 0x0800, - 0xd58: 0x0800, 0xd59: 0x0800, 0xd5a: 0x0800, 0xd5b: 0x0800, 0xd5c: 0x0800, 0xd5d: 0x0800, - 0xd5e: 0x0800, 0xd5f: 0x0800, 0xd60: 0x0800, 0xd61: 0x0800, 0xd62: 0x0800, 0xd63: 0x0800, - 0xd64: 0x0800, 0xd65: 0x0800, 0xd66: 0x0800, 0xd67: 0x0800, 0xd68: 0x0800, 0xd69: 0x0800, - 0xd6a: 0x0800, 0xd6b: 0x0800, 0xd6c: 0x0800, 0xd6d: 0x0800, 0xd6e: 0x0800, 0xd6f: 0x0800, - 0xd70: 0x0800, 0xd71: 0x0800, 0xd72: 0x0800, 0xd73: 0x0800, 0xd74: 0x0800, 0xd75: 0x0800, - 0xd76: 0x0800, 0xd77: 0x0800, 0xd78: 0x0800, 0xd79: 0x0800, 0xd7a: 0x0800, 0xd7b: 0x0800, - 0xd7c: 0x0800, 0xd7d: 0x0800, 0xd7e: 0x0800, 0xd7f: 0x0800, + 0xd40: 0x8000, 0xd41: 0x8000, 0xd42: 0x8000, 0xd43: 0x8000, 0xd44: 0x8000, 0xd45: 0x8000, + 0xd46: 0x8000, 0xd47: 0x8000, 0xd48: 0x8000, 0xd49: 0x8000, 0xd4a: 0x8000, 0xd4b: 0x8000, + 0xd4c: 0x8000, 0xd4d: 0x8000, 0xd4e: 0x8000, 0xd4f: 0x8000, 0xd50: 0x8000, 0xd51: 0x8000, + 0xd52: 0x8000, 0xd53: 0x8000, 0xd54: 0x8000, 0xd55: 0x8000, 0xd56: 0x8000, 0xd57: 0x8000, + 0xd58: 0x8000, 0xd59: 0x8000, 0xd5a: 0x8000, 0xd5b: 0x8000, 0xd5c: 0x8000, 0xd5d: 0x8000, + 0xd5e: 0x8000, 0xd5f: 0x8000, 0xd60: 0x8000, 0xd61: 0x8000, 0xd62: 0x8000, 0xd63: 0x8000, + 0xd64: 0x8000, 0xd65: 0x8000, 0xd66: 0x8000, 0xd67: 0x8000, 0xd68: 0x4000, 0xd69: 0x4000, + 0xd6a: 0x4000, 0xd6b: 0x4000, 0xd6c: 0x4000, 0xd6d: 0x4000, 0xd6e: 0x4000, 0xd6f: 0x4000, + 0xd70: 0x4000, 0xd71: 0x4000, 0xd72: 0x4000, 0xd73: 0x4000, 0xd74: 0x4000, 0xd75: 0x4000, + 0xd76: 0x4000, 0xd77: 0x4000, 0xd78: 0x4000, 0xd79: 0x4000, 0xd7a: 0x4000, 0xd7b: 0x4000, + 0xd7c: 0x4000, 0xd7d: 0x4000, 0xd7e: 0x4000, 0xd7f: 0x4000, // Block 0x36, offset 0xd80 - 0xd9d: 0x0004, - 0xd9e: 0x0004, 0xd9f: 0x0004, + 0xd80: 0x4000, 0xd81: 0x4000, 0xd82: 0x4000, 0xd83: 0x4000, 0xd84: 0x4000, 0xd85: 0x4000, + 0xd86: 0x4000, 0xd87: 0x4000, 0xd88: 0x4000, 0xd89: 0x4000, 0xd8a: 0x4000, 0xd8b: 0x4000, + 0xd8c: 0x4000, 0xd8d: 0x4000, 0xd8e: 0x4000, 0xd8f: 0x4000, 0xd90: 0x4000, 0xd91: 0x4000, + 0xd92: 0x4000, 0xd93: 0x4000, 0xd94: 0x4000, 0xd95: 0x4000, 0xd96: 0x4000, 0xd97: 0x4000, + 0xd98: 0x4000, 0xd99: 0x4000, 0xd9a: 0x4000, 0xd9b: 0x4000, 0xd9c: 0x4000, 0xd9d: 0x4000, + 0xd9e: 0x4000, 0xd9f: 0x4000, 0xda0: 0x4000, 0xda1: 0x4000, 0xda2: 0x4000, 0xda3: 0x4000, + 0xda4: 0x4000, 0xda5: 0x4000, 0xda6: 0x4000, 0xda7: 0x4000, 0xda8: 0x4000, 0xda9: 0x4000, + 0xdaa: 0x4000, 0xdab: 0x4000, 0xdac: 0x4000, 0xdad: 0x4000, 0xdae: 0x4000, 0xdaf: 0x4000, + 0xdb0: 0x4000, 0xdb1: 0x4000, 0xdb2: 0x4000, 0xdb3: 0x4000, 0xdb4: 0x4000, 0xdb5: 0x4000, + 0xdb6: 0x4000, 0xdb7: 0x4000, 0xdb8: 0x4000, 0xdb9: 0x4000, 0xdba: 0x4000, 0xdbb: 0x4000, + 0xdbc: 0x4000, 0xdbd: 0x4000, 0xdbe: 0x4000, 0xdbf: 0x4000, // Block 0x37, offset 0xdc0 - 0xdd2: 0x0004, 0xdd3: 0x0004, 0xdd4: 0x0004, 0xdd5: 0x0400, - 0xdf2: 0x0004, 0xdf3: 0x0004, 0xdf4: 0x0400, + 0xddd: 0x0024, + 0xdde: 0x0024, 0xddf: 0x0024, // Block 0x38, offset 0xe00 - 0xe12: 0x0004, 0xe13: 0x0004, - 0xe32: 0x0004, 0xe33: 0x0004, + 0xe12: 0x0024, 0xe13: 0x0024, 0xe14: 0x0024, 0xe15: 0x0024, + 0xe32: 0x0024, 0xe33: 0x0024, 0xe34: 0x0024, // Block 0x39, offset 0xe40 - 0xe74: 0x0004, 0xe75: 0x0004, - 0xe76: 0x0400, 0xe77: 0x0004, 0xe78: 0x0004, 0xe79: 0x0004, 0xe7a: 0x0004, 0xe7b: 0x0004, - 0xe7c: 0x0004, 0xe7d: 0x0004, 0xe7e: 0x0400, 0xe7f: 0x0400, + 0xe52: 0x0024, 0xe53: 0x0024, + 0xe72: 0x0024, 0xe73: 0x0024, // Block 0x3a, offset 0xe80 - 0xe80: 0x0400, 0xe81: 0x0400, 0xe82: 0x0400, 0xe83: 0x0400, 0xe84: 0x0400, 0xe85: 0x0400, - 0xe86: 0x0004, 0xe87: 0x0400, 0xe88: 0x0400, 0xe89: 0x0004, 0xe8a: 0x0004, 0xe8b: 0x0004, - 0xe8c: 0x0004, 0xe8d: 0x0004, 0xe8e: 0x0004, 0xe8f: 0x0004, 0xe90: 0x0004, 0xe91: 0x0004, - 0xe92: 0x0004, 0xe93: 0x0004, - 0xe9d: 0x0004, + 0xe80: 0x0010, 0xe81: 0x0010, 0xe82: 0x0010, 0xe83: 0x0010, 0xe84: 0x0010, 0xe85: 0x0010, + 0xe86: 0x0010, 0xe87: 0x0010, 0xe88: 0x0010, 0xe89: 0x0010, 0xe8a: 0x0010, 0xe8b: 0x0010, + 0xe8c: 0x0010, 0xe8d: 0x0010, 0xe8e: 0x0010, 0xe8f: 0x0010, 0xe90: 0x0010, 0xe91: 0x0010, + 0xe92: 0x0010, 0xe93: 0x0010, 0xe94: 0x0010, 0xe95: 0x0010, 0xe96: 0x0010, 0xe97: 0x0010, + 0xe98: 0x0010, 0xe99: 0x0010, 0xe9a: 0x0010, 0xe9b: 0x0010, 0xe9c: 0x0010, 0xe9d: 0x0010, + 0xe9e: 0x0010, 0xe9f: 0x0010, 0xea0: 0x0010, 0xea1: 0x0010, 0xea2: 0x0010, 0xea3: 0x0010, + 0xea4: 0x0010, 0xea5: 0x0010, 0xea6: 0x0010, 0xea7: 0x0010, 0xea8: 0x0010, 0xea9: 0x0010, + 0xeaa: 0x0010, 0xeab: 0x0010, 0xeac: 0x0010, 0xead: 0x0010, 0xeae: 0x0010, 0xeaf: 0x0010, + 0xeb0: 0x0010, 0xeb1: 0x0010, 0xeb2: 0x0010, 0xeb3: 0x0010, 0xeb4: 0x0024, 0xeb5: 0x0024, + 0xeb6: 0x2000, 0xeb7: 0x0024, 0xeb8: 0x0024, 0xeb9: 0x0024, 0xeba: 0x0024, 0xebb: 0x0024, + 0xebc: 0x0024, 0xebd: 0x0024, 0xebe: 0x2000, 0xebf: 0x2000, // Block 0x3b, offset 0xec0 - 0xecb: 0x0004, - 0xecc: 0x0004, 0xecd: 0x0004, 0xece: 0x0002, 0xecf: 0x0004, + 0xec0: 0x2000, 0xec1: 0x2000, 0xec2: 0x2000, 0xec3: 0x2000, 0xec4: 0x2000, 0xec5: 0x2000, + 0xec6: 0x0024, 0xec7: 0x2000, 0xec8: 0x2000, 0xec9: 0x0024, 0xeca: 0x0024, 0xecb: 0x0024, + 0xecc: 0x0024, 0xecd: 0x0024, 0xece: 0x0024, 0xecf: 0x0024, 0xed0: 0x0024, 0xed1: 0x0024, + 0xed2: 0x0044, 0xed3: 0x0024, + 0xedd: 0x0024, // Block 0x3c, offset 0xf00 - 0xf05: 0x0004, - 0xf06: 0x0004, - 0xf29: 0x0004, + 0xf0b: 0x0024, + 0xf0c: 0x0024, 0xf0d: 0x0024, 0xf0e: 0x0002, 0xf0f: 0x0024, // Block 0x3d, offset 0xf40 - 0xf60: 0x0004, 0xf61: 0x0004, 0xf62: 0x0004, 0xf63: 0x0400, - 0xf64: 0x0400, 0xf65: 0x0400, 0xf66: 0x0400, 0xf67: 0x0004, 0xf68: 0x0004, 0xf69: 0x0400, - 0xf6a: 0x0400, 0xf6b: 0x0400, - 0xf70: 0x0400, 0xf71: 0x0400, 0xf72: 0x0004, 0xf73: 0x0400, 0xf74: 0x0400, 0xf75: 0x0400, - 0xf76: 0x0400, 0xf77: 0x0400, 0xf78: 0x0400, 0xf79: 0x0004, 0xf7a: 0x0004, 0xf7b: 0x0004, + 0xf45: 0x0024, + 0xf46: 0x0024, + 0xf69: 0x0024, // Block 0x3e, offset 0xf80 - 0xf97: 0x0004, - 0xf98: 0x0004, 0xf99: 0x0400, 0xf9a: 0x0400, 0xf9b: 0x0004, + 0xfa0: 0x0024, 0xfa1: 0x0024, 0xfa2: 0x0024, 0xfa3: 0x2000, + 0xfa4: 0x2000, 0xfa5: 0x2000, 0xfa6: 0x2000, 0xfa7: 0x0024, 0xfa8: 0x0024, 0xfa9: 0x2000, + 0xfaa: 0x2000, 0xfab: 0x2000, + 0xfb0: 0x2000, 0xfb1: 0x2000, 0xfb2: 0x0024, 0xfb3: 0x2000, 0xfb4: 0x2000, 0xfb5: 0x2000, + 0xfb6: 0x2000, 0xfb7: 0x2000, 0xfb8: 0x2000, 0xfb9: 0x0024, 0xfba: 0x0024, 0xfbb: 0x0024, // Block 0x3f, offset 0xfc0 - 0xfd5: 0x0400, 0xfd6: 0x0004, 0xfd7: 0x0400, - 0xfd8: 0x0004, 0xfd9: 0x0004, 0xfda: 0x0004, 0xfdb: 0x0004, 0xfdc: 0x0004, 0xfdd: 0x0004, - 0xfde: 0x0004, 0xfe0: 0x0004, 0xfe2: 0x0004, - 0xfe5: 0x0004, 0xfe6: 0x0004, 0xfe7: 0x0004, 0xfe8: 0x0004, 0xfe9: 0x0004, - 0xfea: 0x0004, 0xfeb: 0x0004, 0xfec: 0x0004, 0xfed: 0x0400, 0xfee: 0x0400, 0xfef: 0x0400, - 0xff0: 0x0400, 0xff1: 0x0400, 0xff2: 0x0400, 0xff3: 0x0004, 0xff4: 0x0004, 0xff5: 0x0004, - 0xff6: 0x0004, 0xff7: 0x0004, 0xff8: 0x0004, 0xff9: 0x0004, 0xffa: 0x0004, 0xffb: 0x0004, - 0xffc: 0x0004, 0xfff: 0x0004, + 0xfd7: 0x0024, + 0xfd8: 0x0024, 0xfd9: 0x2000, 0xfda: 0x2000, 0xfdb: 0x0024, + 0xfe0: 0x0010, 0xfe1: 0x0010, 0xfe2: 0x0010, 0xfe3: 0x0010, + 0xfe4: 0x0010, 0xfe5: 0x0010, 0xfe6: 0x0010, 0xfe7: 0x0010, 0xfe8: 0x0010, 0xfe9: 0x0010, + 0xfea: 0x0010, 0xfeb: 0x0010, 0xfec: 0x0010, 0xfed: 0x0010, 0xfee: 0x0010, 0xfef: 0x0010, + 0xff0: 0x0010, 0xff1: 0x0010, 0xff2: 0x0010, 0xff3: 0x0010, 0xff4: 0x0010, 0xff5: 0x0010, + 0xff6: 0x0010, 0xff7: 0x0010, 0xff8: 0x0010, 0xff9: 0x0010, 0xffa: 0x0010, 0xffb: 0x0010, + 0xffc: 0x0010, 0xffd: 0x0010, 0xffe: 0x0010, 0xfff: 0x0010, // Block 0x40, offset 0x1000 - 0x1030: 0x0004, 0x1031: 0x0004, 0x1032: 0x0004, 0x1033: 0x0004, 0x1034: 0x0004, 0x1035: 0x0004, - 0x1036: 0x0004, 0x1037: 0x0004, 0x1038: 0x0004, 0x1039: 0x0004, 0x103a: 0x0004, 0x103b: 0x0004, - 0x103c: 0x0004, 0x103d: 0x0004, 0x103e: 0x0004, 0x103f: 0x0004, + 0x1000: 0x0010, 0x1001: 0x0010, 0x1002: 0x0010, 0x1003: 0x0010, 0x1004: 0x0010, 0x1005: 0x0010, + 0x1006: 0x0010, 0x1007: 0x0010, 0x1008: 0x0010, 0x1009: 0x0010, 0x100a: 0x0010, 0x100b: 0x0010, + 0x100c: 0x0010, 0x100d: 0x0010, 0x100e: 0x0010, 0x100f: 0x0010, 0x1010: 0x0010, 0x1011: 0x0010, + 0x1012: 0x0010, 0x1013: 0x0010, 0x1014: 0x0010, 0x1015: 0x2000, 0x1016: 0x0024, 0x1017: 0x2000, + 0x1018: 0x0024, 0x1019: 0x0024, 0x101a: 0x0024, 0x101b: 0x0024, 0x101c: 0x0024, 0x101d: 0x0024, + 0x101e: 0x0024, 0x1020: 0x0044, 0x1022: 0x0024, + 0x1025: 0x0024, 0x1026: 0x0024, 0x1027: 0x0024, 0x1028: 0x0024, 0x1029: 0x0024, + 0x102a: 0x0024, 0x102b: 0x0024, 0x102c: 0x0024, 0x102d: 0x2000, 0x102e: 0x2000, 0x102f: 0x2000, + 0x1030: 0x2000, 0x1031: 0x2000, 0x1032: 0x2000, 0x1033: 0x0024, 0x1034: 0x0024, 0x1035: 0x0024, + 0x1036: 0x0024, 0x1037: 0x0024, 0x1038: 0x0024, 0x1039: 0x0024, 0x103a: 0x0024, 0x103b: 0x0024, + 0x103c: 0x0024, 0x103f: 0x0024, // Block 0x41, offset 0x1040 - 0x1040: 0x0004, 0x1041: 0x0004, 0x1042: 0x0004, 0x1043: 0x0004, 0x1044: 0x0004, 0x1045: 0x0004, - 0x1046: 0x0004, 0x1047: 0x0004, 0x1048: 0x0004, 0x1049: 0x0004, 0x104a: 0x0004, 0x104b: 0x0004, - 0x104c: 0x0004, 0x104d: 0x0004, 0x104e: 0x0004, + 0x1070: 0x0024, 0x1071: 0x0024, 0x1072: 0x0024, 0x1073: 0x0024, 0x1074: 0x0024, 0x1075: 0x0024, + 0x1076: 0x0024, 0x1077: 0x0024, 0x1078: 0x0024, 0x1079: 0x0024, 0x107a: 0x0024, 0x107b: 0x0024, + 0x107c: 0x0024, 0x107d: 0x0024, 0x107e: 0x0024, 0x107f: 0x0024, // Block 0x42, offset 0x1080 - 0x1080: 0x0004, 0x1081: 0x0004, 0x1082: 0x0004, 0x1083: 0x0004, 0x1084: 0x0400, - 0x10b4: 0x0004, 0x10b5: 0x0004, - 0x10b6: 0x0004, 0x10b7: 0x0004, 0x10b8: 0x0004, 0x10b9: 0x0004, 0x10ba: 0x0004, 0x10bb: 0x0400, - 0x10bc: 0x0004, 0x10bd: 0x0400, 0x10be: 0x0400, 0x10bf: 0x0400, + 0x1080: 0x0024, 0x1081: 0x0024, 0x1082: 0x0024, 0x1083: 0x0024, 0x1084: 0x0024, 0x1085: 0x0024, + 0x1086: 0x0024, 0x1087: 0x0024, 0x1088: 0x0024, 0x1089: 0x0024, 0x108a: 0x0024, 0x108b: 0x0024, + 0x108c: 0x0024, 0x108d: 0x0024, 0x108e: 0x0024, 0x108f: 0x0024, 0x1090: 0x0024, 0x1091: 0x0024, + 0x1092: 0x0024, 0x1093: 0x0024, 0x1094: 0x0024, 0x1095: 0x0024, 0x1096: 0x0024, 0x1097: 0x0024, + 0x1098: 0x0024, 0x1099: 0x0024, 0x109a: 0x0024, 0x109b: 0x0024, 0x109c: 0x0024, 0x109d: 0x0024, + 0x10a0: 0x0024, 0x10a1: 0x0024, 0x10a2: 0x0024, 0x10a3: 0x0024, + 0x10a4: 0x0024, 0x10a5: 0x0024, 0x10a6: 0x0024, 0x10a7: 0x0024, 0x10a8: 0x0024, 0x10a9: 0x0024, + 0x10aa: 0x0024, 0x10ab: 0x0024, // Block 0x43, offset 0x10c0 - 0x10c0: 0x0400, 0x10c1: 0x0400, 0x10c2: 0x0004, 0x10c3: 0x0400, 0x10c4: 0x0400, - 0x10eb: 0x0004, 0x10ec: 0x0004, 0x10ed: 0x0004, 0x10ee: 0x0004, 0x10ef: 0x0004, - 0x10f0: 0x0004, 0x10f1: 0x0004, 0x10f2: 0x0004, 0x10f3: 0x0004, + 0x10c0: 0x0024, 0x10c1: 0x0024, 0x10c2: 0x0024, 0x10c3: 0x0024, 0x10c4: 0x2000, + 0x10cb: 0x0010, + 0x10cc: 0x0010, + 0x10d3: 0x0010, 0x10d4: 0x0010, 0x10d5: 0x0010, 0x10d6: 0x0010, 0x10d7: 0x0010, + 0x10d8: 0x0010, 0x10d9: 0x0010, 0x10da: 0x0010, 0x10db: 0x0010, 0x10dc: 0x0010, 0x10dd: 0x0010, + 0x10de: 0x0010, 0x10df: 0x0010, 0x10e0: 0x0010, 0x10e1: 0x0010, 0x10e2: 0x0010, 0x10e3: 0x0010, + 0x10e4: 0x0010, 0x10e5: 0x0010, 0x10e6: 0x0010, 0x10e7: 0x0010, 0x10e8: 0x0010, 0x10e9: 0x0010, + 0x10ea: 0x0010, 0x10eb: 0x0010, 0x10ec: 0x0010, 0x10ed: 0x0010, 0x10ee: 0x0010, 0x10ef: 0x0010, + 0x10f0: 0x0010, 0x10f1: 0x0010, 0x10f2: 0x0010, 0x10f3: 0x0010, 0x10f4: 0x0024, 0x10f5: 0x0024, + 0x10f6: 0x0024, 0x10f7: 0x0024, 0x10f8: 0x0024, 0x10f9: 0x0024, 0x10fa: 0x0024, 0x10fb: 0x0024, + 0x10fc: 0x0024, 0x10fd: 0x0024, 0x10fe: 0x2000, 0x10ff: 0x2000, // Block 0x44, offset 0x1100 - 0x1100: 0x0004, 0x1101: 0x0004, 0x1102: 0x0400, - 0x1121: 0x0400, 0x1122: 0x0004, 0x1123: 0x0004, - 0x1124: 0x0004, 0x1125: 0x0004, 0x1126: 0x0400, 0x1127: 0x0400, 0x1128: 0x0004, 0x1129: 0x0004, - 0x112a: 0x0400, 0x112b: 0x0004, 0x112c: 0x0004, 0x112d: 0x0004, + 0x1100: 0x2000, 0x1101: 0x2000, 0x1102: 0x0024, 0x1103: 0x0024, 0x1104: 0x0044, 0x1105: 0x0010, + 0x1106: 0x0010, 0x1107: 0x0010, 0x1108: 0x0010, 0x1109: 0x0010, 0x110a: 0x0010, 0x110b: 0x0010, + 0x110c: 0x0010, + 0x112b: 0x0024, 0x112c: 0x0024, 0x112d: 0x0024, 0x112e: 0x0024, 0x112f: 0x0024, + 0x1130: 0x0024, 0x1131: 0x0024, 0x1132: 0x0024, 0x1133: 0x0024, // Block 0x45, offset 0x1140 - 0x1166: 0x0004, 0x1167: 0x0400, 0x1168: 0x0004, 0x1169: 0x0004, - 0x116a: 0x0400, 0x116b: 0x0400, 0x116c: 0x0400, 0x116d: 0x0004, 0x116e: 0x0400, 0x116f: 0x0004, - 0x1170: 0x0004, 0x1171: 0x0004, 0x1172: 0x0400, 0x1173: 0x0400, + 0x1140: 0x0024, 0x1141: 0x0024, 0x1142: 0x2000, 0x1143: 0x0010, 0x1144: 0x0010, 0x1145: 0x0010, + 0x1146: 0x0010, 0x1147: 0x0010, 0x1148: 0x0010, 0x1149: 0x0010, 0x114a: 0x0010, 0x114b: 0x0010, + 0x114c: 0x0010, 0x114d: 0x0010, 0x114e: 0x0010, 0x114f: 0x0010, 0x1150: 0x0010, 0x1151: 0x0010, + 0x1152: 0x0010, 0x1153: 0x0010, 0x1154: 0x0010, 0x1155: 0x0010, 0x1156: 0x0010, 0x1157: 0x0010, + 0x1158: 0x0010, 0x1159: 0x0010, 0x115a: 0x0010, 0x115b: 0x0010, 0x115c: 0x0010, 0x115d: 0x0010, + 0x115e: 0x0010, 0x115f: 0x0010, 0x1160: 0x0010, 0x1161: 0x2000, 0x1162: 0x0024, 0x1163: 0x0024, + 0x1164: 0x0024, 0x1165: 0x0024, 0x1166: 0x2000, 0x1167: 0x2000, 0x1168: 0x0024, 0x1169: 0x0024, + 0x116a: 0x0024, 0x116b: 0x0044, 0x116c: 0x0024, 0x116d: 0x0024, 0x116e: 0x0010, 0x116f: 0x0010, + 0x117b: 0x0010, + 0x117c: 0x0010, 0x117d: 0x0010, // Block 0x46, offset 0x1180 - 0x11a4: 0x0400, 0x11a5: 0x0400, 0x11a6: 0x0400, 0x11a7: 0x0400, 0x11a8: 0x0400, 0x11a9: 0x0400, - 0x11aa: 0x0400, 0x11ab: 0x0400, 0x11ac: 0x0004, 0x11ad: 0x0004, 0x11ae: 0x0004, 0x11af: 0x0004, - 0x11b0: 0x0004, 0x11b1: 0x0004, 0x11b2: 0x0004, 0x11b3: 0x0004, 0x11b4: 0x0400, 0x11b5: 0x0400, - 0x11b6: 0x0004, 0x11b7: 0x0004, + 0x11a6: 0x0024, 0x11a7: 0x2000, 0x11a8: 0x0024, 0x11a9: 0x0024, + 0x11aa: 0x2000, 0x11ab: 0x2000, 0x11ac: 0x2000, 0x11ad: 0x0024, 0x11ae: 0x2000, 0x11af: 0x0024, + 0x11b0: 0x0024, 0x11b1: 0x0024, 0x11b2: 0x0024, 0x11b3: 0x0024, // Block 0x47, offset 0x11c0 - 0x11d0: 0x0004, 0x11d1: 0x0004, - 0x11d2: 0x0004, 0x11d4: 0x0004, 0x11d5: 0x0004, 0x11d6: 0x0004, 0x11d7: 0x0004, - 0x11d8: 0x0004, 0x11d9: 0x0004, 0x11da: 0x0004, 0x11db: 0x0004, 0x11dc: 0x0004, 0x11dd: 0x0004, - 0x11de: 0x0004, 0x11df: 0x0004, 0x11e0: 0x0004, 0x11e1: 0x0400, 0x11e2: 0x0004, 0x11e3: 0x0004, - 0x11e4: 0x0004, 0x11e5: 0x0004, 0x11e6: 0x0004, 0x11e7: 0x0004, 0x11e8: 0x0004, - 0x11ed: 0x0004, - 0x11f4: 0x0004, - 0x11f7: 0x0400, 0x11f8: 0x0004, 0x11f9: 0x0004, + 0x11e4: 0x2000, 0x11e5: 0x2000, 0x11e6: 0x2000, 0x11e7: 0x2000, 0x11e8: 0x2000, 0x11e9: 0x2000, + 0x11ea: 0x2000, 0x11eb: 0x2000, 0x11ec: 0x0024, 0x11ed: 0x0024, 0x11ee: 0x0024, 0x11ef: 0x0024, + 0x11f0: 0x0024, 0x11f1: 0x0024, 0x11f2: 0x0024, 0x11f3: 0x0024, 0x11f4: 0x2000, 0x11f5: 0x2000, + 0x11f6: 0x0024, 0x11f7: 0x0024, // Block 0x48, offset 0x1200 - 0x120b: 0x0002, - 0x120c: 0x0004, 0x120d: 0x2000, 0x120e: 0x0002, 0x120f: 0x0002, - 0x1228: 0x0002, 0x1229: 0x0002, - 0x122a: 0x0002, 0x122b: 0x0002, 0x122c: 0x0002, 0x122d: 0x0002, 0x122e: 0x0002, - 0x123c: 0x0008, + 0x1210: 0x0024, 0x1211: 0x0024, + 0x1212: 0x0024, 0x1214: 0x0024, 0x1215: 0x0024, 0x1216: 0x0024, 0x1217: 0x0024, + 0x1218: 0x0024, 0x1219: 0x0024, 0x121a: 0x0024, 0x121b: 0x0024, 0x121c: 0x0024, 0x121d: 0x0024, + 0x121e: 0x0024, 0x121f: 0x0024, 0x1220: 0x0024, 0x1221: 0x2000, 0x1222: 0x0024, 0x1223: 0x0024, + 0x1224: 0x0024, 0x1225: 0x0024, 0x1226: 0x0024, 0x1227: 0x0024, 0x1228: 0x0024, + 0x122d: 0x0024, + 0x1234: 0x0024, + 0x1237: 0x2000, 0x1238: 0x0024, 0x1239: 0x0024, // Block 0x49, offset 0x1240 - 0x1249: 0x0008, - 0x1260: 0x0002, 0x1261: 0x0002, 0x1262: 0x0002, 0x1263: 0x0002, - 0x1264: 0x0002, 0x1265: 0x0002, 0x1266: 0x0002, 0x1267: 0x0002, 0x1268: 0x0002, 0x1269: 0x0002, - 0x126a: 0x0002, 0x126b: 0x0002, 0x126c: 0x0002, 0x126d: 0x0002, 0x126e: 0x0002, 0x126f: 0x0002, + 0x124b: 0x0002, + 0x124c: 0x0004, 0x124d: 0x10020, 0x124e: 0x0002, 0x124f: 0x0002, + 0x1268: 0x0002, 0x1269: 0x0002, + 0x126a: 0x0002, 0x126b: 0x0002, 0x126c: 0x0002, 0x126d: 0x0002, 0x126e: 0x0002, + 0x127c: 0x0008, // Block 0x4a, offset 0x1280 - 0x1290: 0x0004, 0x1291: 0x0004, - 0x1292: 0x0004, 0x1293: 0x0004, 0x1294: 0x0004, 0x1295: 0x0004, 0x1296: 0x0004, 0x1297: 0x0004, - 0x1298: 0x0004, 0x1299: 0x0004, 0x129a: 0x0004, 0x129b: 0x0004, 0x129c: 0x0004, 0x129d: 0x0004, - 0x129e: 0x0004, 0x129f: 0x0004, 0x12a0: 0x0004, 0x12a1: 0x0004, 0x12a2: 0x0004, 0x12a3: 0x0004, - 0x12a4: 0x0004, 0x12a5: 0x0004, 0x12a6: 0x0004, 0x12a7: 0x0004, 0x12a8: 0x0004, 0x12a9: 0x0004, - 0x12aa: 0x0004, 0x12ab: 0x0004, 0x12ac: 0x0004, 0x12ad: 0x0004, 0x12ae: 0x0004, 0x12af: 0x0004, - 0x12b0: 0x0004, + 0x1289: 0x0008, + 0x12a0: 0x0002, 0x12a1: 0x0002, 0x12a2: 0x0002, 0x12a3: 0x0002, + 0x12a4: 0x0002, 0x12a5: 0x0002, 0x12a6: 0x0002, 0x12a7: 0x0002, 0x12a8: 0x0002, 0x12a9: 0x0002, + 0x12aa: 0x0002, 0x12ab: 0x0002, 0x12ac: 0x0002, 0x12ad: 0x0002, 0x12ae: 0x0002, 0x12af: 0x0002, // Block 0x4b, offset 0x12c0 - 0x12e2: 0x0008, - 0x12f9: 0x0008, + 0x12d0: 0x0024, 0x12d1: 0x0024, + 0x12d2: 0x0024, 0x12d3: 0x0024, 0x12d4: 0x0024, 0x12d5: 0x0024, 0x12d6: 0x0024, 0x12d7: 0x0024, + 0x12d8: 0x0024, 0x12d9: 0x0024, 0x12da: 0x0024, 0x12db: 0x0024, 0x12dc: 0x0024, 0x12dd: 0x0024, + 0x12de: 0x0024, 0x12df: 0x0024, 0x12e0: 0x0024, 0x12e1: 0x0024, 0x12e2: 0x0024, 0x12e3: 0x0024, + 0x12e4: 0x0024, 0x12e5: 0x0024, 0x12e6: 0x0024, 0x12e7: 0x0024, 0x12e8: 0x0024, 0x12e9: 0x0024, + 0x12ea: 0x0024, 0x12eb: 0x0024, 0x12ec: 0x0024, 0x12ed: 0x0024, 0x12ee: 0x0024, 0x12ef: 0x0024, + 0x12f0: 0x0024, // Block 0x4c, offset 0x1300 - 0x1314: 0x0008, 0x1315: 0x0008, 0x1316: 0x0008, 0x1317: 0x0008, - 0x1318: 0x0008, 0x1319: 0x0008, - 0x1329: 0x0008, - 0x132a: 0x0008, + 0x1322: 0x0008, + 0x1339: 0x0008, // Block 0x4d, offset 0x1340 - 0x135a: 0x0008, 0x135b: 0x0008, - 0x1368: 0x0008, + 0x1354: 0x0008, 0x1355: 0x0008, 0x1356: 0x0008, 0x1357: 0x0008, + 0x1358: 0x0008, 0x1359: 0x0008, + 0x1369: 0x0008, + 0x136a: 0x0008, // Block 0x4e, offset 0x1380 - 0x1388: 0x0008, + 0x139a: 0x0008, 0x139b: 0x0008, + 0x13a8: 0x0008, // Block 0x4f, offset 0x13c0 0x13cf: 0x0008, 0x13e9: 0x0008, @@ -539,746 +639,951 @@ var graphemesValues = [13760]property{ 0x14bb: 0x0008, 0x14bc: 0x0008, 0x14bd: 0x0008, 0x14be: 0x0008, // Block 0x53, offset 0x14c0 - 0x14c0: 0x0008, 0x14c1: 0x0008, 0x14c2: 0x0008, 0x14c3: 0x0008, 0x14c4: 0x0008, 0x14c5: 0x0008, - 0x14c7: 0x0008, 0x14c8: 0x0008, 0x14c9: 0x0008, 0x14ca: 0x0008, 0x14cb: 0x0008, - 0x14cc: 0x0008, 0x14cd: 0x0008, 0x14ce: 0x0008, 0x14cf: 0x0008, 0x14d0: 0x0008, 0x14d1: 0x0008, - 0x14d2: 0x0008, 0x14d4: 0x0008, 0x14d5: 0x0008, 0x14d6: 0x0008, 0x14d7: 0x0008, - 0x14d8: 0x0008, 0x14d9: 0x0008, 0x14da: 0x0008, 0x14db: 0x0008, 0x14dc: 0x0008, 0x14dd: 0x0008, - 0x14de: 0x0008, 0x14df: 0x0008, 0x14e0: 0x0008, 0x14e1: 0x0008, 0x14e2: 0x0008, 0x14e3: 0x0008, - 0x14e4: 0x0008, 0x14e5: 0x0008, 0x14e6: 0x0008, 0x14e7: 0x0008, 0x14e8: 0x0008, 0x14e9: 0x0008, - 0x14ea: 0x0008, 0x14eb: 0x0008, 0x14ec: 0x0008, 0x14ed: 0x0008, 0x14ee: 0x0008, 0x14ef: 0x0008, - 0x14f0: 0x0008, 0x14f1: 0x0008, 0x14f2: 0x0008, 0x14f3: 0x0008, 0x14f4: 0x0008, 0x14f5: 0x0008, - 0x14f6: 0x0008, 0x14f7: 0x0008, 0x14f8: 0x0008, 0x14f9: 0x0008, 0x14fa: 0x0008, 0x14fb: 0x0008, - 0x14fc: 0x0008, 0x14fd: 0x0008, 0x14fe: 0x0008, 0x14ff: 0x0008, + 0x14c0: 0x0008, 0x14c1: 0x0008, 0x14c2: 0x0008, 0x14c3: 0x0008, 0x14c4: 0x0008, + 0x14ce: 0x0008, 0x14d1: 0x0008, + 0x14d4: 0x0008, 0x14d5: 0x0008, + 0x14d8: 0x0008, 0x14dd: 0x0008, + 0x14e0: 0x0008, 0x14e2: 0x0008, 0x14e3: 0x0008, + 0x14e6: 0x0008, + 0x14ea: 0x0008, 0x14ee: 0x0008, 0x14ef: 0x0008, + 0x14f8: 0x0008, 0x14f9: 0x0008, 0x14fa: 0x0008, // Block 0x54, offset 0x1500 - 0x1500: 0x0008, 0x1501: 0x0008, 0x1502: 0x0008, 0x1503: 0x0008, 0x1504: 0x0008, 0x1505: 0x0008, - 0x1506: 0x0008, 0x1507: 0x0008, 0x1508: 0x0008, 0x1509: 0x0008, 0x150a: 0x0008, 0x150b: 0x0008, + 0x1500: 0x0008, 0x1502: 0x0008, + 0x1508: 0x0008, 0x1509: 0x0008, 0x150a: 0x0008, 0x150b: 0x0008, 0x150c: 0x0008, 0x150d: 0x0008, 0x150e: 0x0008, 0x150f: 0x0008, 0x1510: 0x0008, 0x1511: 0x0008, - 0x1512: 0x0008, 0x1513: 0x0008, 0x1514: 0x0008, 0x1515: 0x0008, 0x1516: 0x0008, 0x1517: 0x0008, - 0x1518: 0x0008, 0x1519: 0x0008, 0x151a: 0x0008, 0x151b: 0x0008, 0x151c: 0x0008, 0x151d: 0x0008, - 0x151e: 0x0008, 0x151f: 0x0008, 0x1520: 0x0008, 0x1521: 0x0008, 0x1522: 0x0008, 0x1523: 0x0008, - 0x1524: 0x0008, 0x1525: 0x0008, 0x1526: 0x0008, 0x1527: 0x0008, 0x1528: 0x0008, 0x1529: 0x0008, - 0x152a: 0x0008, 0x152b: 0x0008, 0x152c: 0x0008, 0x152d: 0x0008, 0x152e: 0x0008, 0x152f: 0x0008, - 0x1530: 0x0008, 0x1531: 0x0008, 0x1532: 0x0008, 0x1533: 0x0008, 0x1534: 0x0008, 0x1535: 0x0008, - 0x1536: 0x0008, 0x1537: 0x0008, 0x1538: 0x0008, 0x1539: 0x0008, 0x153a: 0x0008, 0x153b: 0x0008, - 0x153c: 0x0008, 0x153d: 0x0008, 0x153e: 0x0008, 0x153f: 0x0008, + 0x1512: 0x0008, 0x1513: 0x0008, + 0x151f: 0x0008, 0x1520: 0x0008, 0x1523: 0x0008, + 0x1525: 0x0008, 0x1526: 0x0008, 0x1528: 0x0008, + 0x153b: 0x0008, + 0x153e: 0x0008, 0x153f: 0x0008, // Block 0x55, offset 0x1540 - 0x1540: 0x0008, 0x1541: 0x0008, 0x1542: 0x0008, 0x1543: 0x0008, 0x1544: 0x0008, 0x1545: 0x0008, - 0x1550: 0x0008, 0x1551: 0x0008, 0x1552: 0x0008, 0x1553: 0x0008, 0x1554: 0x0008, 0x1555: 0x0008, 0x1556: 0x0008, 0x1557: 0x0008, - 0x1558: 0x0008, 0x1559: 0x0008, 0x155a: 0x0008, 0x155b: 0x0008, 0x155c: 0x0008, 0x155d: 0x0008, - 0x155e: 0x0008, 0x155f: 0x0008, 0x1560: 0x0008, 0x1561: 0x0008, 0x1562: 0x0008, 0x1563: 0x0008, - 0x1564: 0x0008, 0x1565: 0x0008, 0x1566: 0x0008, 0x1567: 0x0008, 0x1568: 0x0008, 0x1569: 0x0008, - 0x156a: 0x0008, 0x156b: 0x0008, 0x156c: 0x0008, 0x156d: 0x0008, 0x156e: 0x0008, 0x156f: 0x0008, - 0x1570: 0x0008, 0x1571: 0x0008, 0x1572: 0x0008, 0x1573: 0x0008, 0x1574: 0x0008, 0x1575: 0x0008, - 0x1576: 0x0008, 0x1577: 0x0008, 0x1578: 0x0008, 0x1579: 0x0008, 0x157a: 0x0008, 0x157b: 0x0008, - 0x157c: 0x0008, 0x157d: 0x0008, 0x157e: 0x0008, 0x157f: 0x0008, + 0x1559: 0x0008, 0x155b: 0x0008, 0x155c: 0x0008, + 0x1560: 0x0008, 0x1561: 0x0008, + 0x1567: 0x0008, + 0x156a: 0x0008, 0x156b: 0x0008, + 0x1570: 0x0008, 0x1571: 0x0008, + 0x157d: 0x0008, 0x157e: 0x0008, // Block 0x56, offset 0x1580 - 0x1580: 0x0008, 0x1581: 0x0008, 0x1582: 0x0008, 0x1583: 0x0008, 0x1584: 0x0008, 0x1585: 0x0008, - 0x1588: 0x0008, 0x1589: 0x0008, 0x158a: 0x0008, 0x158b: 0x0008, - 0x158c: 0x0008, 0x158d: 0x0008, 0x158e: 0x0008, 0x158f: 0x0008, 0x1590: 0x0008, 0x1591: 0x0008, - 0x1592: 0x0008, 0x1594: 0x0008, 0x1596: 0x0008, - 0x159d: 0x0008, - 0x15a1: 0x0008, - 0x15a8: 0x0008, - 0x15b3: 0x0008, 0x15b4: 0x0008, + 0x1584: 0x0008, 0x1585: 0x0008, + 0x1588: 0x0008, + 0x158e: 0x0008, 0x158f: 0x0008, 0x1591: 0x0008, + 0x1593: 0x0008, 0x1594: 0x0008, + 0x15a9: 0x0008, + 0x15aa: 0x0008, + 0x15b0: 0x0008, 0x15b1: 0x0008, 0x15b2: 0x0008, 0x15b3: 0x0008, 0x15b4: 0x0008, 0x15b5: 0x0008, + 0x15b7: 0x0008, 0x15b8: 0x0008, 0x15b9: 0x0008, 0x15ba: 0x0008, + 0x15bd: 0x0008, // Block 0x57, offset 0x15c0 - 0x15c4: 0x0008, - 0x15c7: 0x0008, - 0x15cc: 0x0008, 0x15ce: 0x0008, - 0x15d3: 0x0008, 0x15d4: 0x0008, 0x15d5: 0x0008, 0x15d7: 0x0008, - 0x15e3: 0x0008, - 0x15e4: 0x0008, 0x15e5: 0x0008, 0x15e6: 0x0008, 0x15e7: 0x0008, + 0x15c2: 0x0008, 0x15c5: 0x0008, + 0x15c8: 0x0008, 0x15c9: 0x0008, 0x15ca: 0x0008, 0x15cb: 0x0008, + 0x15cc: 0x0008, 0x15cd: 0x0008, 0x15cf: 0x0008, + 0x15d2: 0x0008, 0x15d4: 0x0008, 0x15d6: 0x0008, + 0x15dd: 0x0008, + 0x15e1: 0x0008, + 0x15e8: 0x0008, + 0x15f3: 0x0008, 0x15f4: 0x0008, // Block 0x58, offset 0x1600 - 0x1615: 0x0008, 0x1616: 0x0008, 0x1617: 0x0008, - 0x1621: 0x0008, - 0x1630: 0x0008, - 0x163f: 0x0008, + 0x1604: 0x0008, + 0x1607: 0x0008, + 0x160c: 0x0008, 0x160e: 0x0008, + 0x1613: 0x0008, 0x1614: 0x0008, 0x1615: 0x0008, 0x1617: 0x0008, + 0x1623: 0x0008, + 0x1624: 0x0008, // Block 0x59, offset 0x1640 - 0x1674: 0x0008, 0x1675: 0x0008, + 0x1655: 0x0008, 0x1656: 0x0008, 0x1657: 0x0008, + 0x1661: 0x0008, + 0x1670: 0x0008, + 0x167f: 0x0008, // Block 0x5a, offset 0x1680 - 0x1685: 0x0008, - 0x1686: 0x0008, 0x1687: 0x0008, - 0x169b: 0x0008, 0x169c: 0x0008, + 0x16b4: 0x0008, 0x16b5: 0x0008, // Block 0x5b, offset 0x16c0 - 0x16d0: 0x0008, - 0x16d5: 0x0008, + 0x16c5: 0x0008, + 0x16c6: 0x0008, 0x16c7: 0x0008, + 0x16db: 0x0008, 0x16dc: 0x0008, // Block 0x5c, offset 0x1700 - 0x172f: 0x0004, - 0x1730: 0x0004, 0x1731: 0x0004, + 0x1710: 0x0008, + 0x1715: 0x0008, // Block 0x5d, offset 0x1740 - 0x177f: 0x0004, + 0x176f: 0x0024, + 0x1770: 0x0024, 0x1771: 0x0024, // Block 0x5e, offset 0x1780 - 0x17a0: 0x0004, 0x17a1: 0x0004, 0x17a2: 0x0004, 0x17a3: 0x0004, - 0x17a4: 0x0004, 0x17a5: 0x0004, 0x17a6: 0x0004, 0x17a7: 0x0004, 0x17a8: 0x0004, 0x17a9: 0x0004, - 0x17aa: 0x0004, 0x17ab: 0x0004, 0x17ac: 0x0004, 0x17ad: 0x0004, 0x17ae: 0x0004, 0x17af: 0x0004, - 0x17b0: 0x0004, 0x17b1: 0x0004, 0x17b2: 0x0004, 0x17b3: 0x0004, 0x17b4: 0x0004, 0x17b5: 0x0004, - 0x17b6: 0x0004, 0x17b7: 0x0004, 0x17b8: 0x0004, 0x17b9: 0x0004, 0x17ba: 0x0004, 0x17bb: 0x0004, - 0x17bc: 0x0004, 0x17bd: 0x0004, 0x17be: 0x0004, 0x17bf: 0x0004, + 0x17bf: 0x0024, // Block 0x5f, offset 0x17c0 - 0x17ea: 0x0004, 0x17eb: 0x0004, 0x17ec: 0x0004, 0x17ed: 0x0004, 0x17ee: 0x0004, 0x17ef: 0x0004, - 0x17f0: 0x0008, - 0x17fd: 0x0008, + 0x17e0: 0x0024, 0x17e1: 0x0024, 0x17e2: 0x0024, 0x17e3: 0x0024, + 0x17e4: 0x0024, 0x17e5: 0x0024, 0x17e6: 0x0024, 0x17e7: 0x0024, 0x17e8: 0x0024, 0x17e9: 0x0024, + 0x17ea: 0x0024, 0x17eb: 0x0024, 0x17ec: 0x0024, 0x17ed: 0x0024, 0x17ee: 0x0024, 0x17ef: 0x0024, + 0x17f0: 0x0024, 0x17f1: 0x0024, 0x17f2: 0x0024, 0x17f3: 0x0024, 0x17f4: 0x0024, 0x17f5: 0x0024, + 0x17f6: 0x0024, 0x17f7: 0x0024, 0x17f8: 0x0024, 0x17f9: 0x0024, 0x17fa: 0x0024, 0x17fb: 0x0024, + 0x17fc: 0x0024, 0x17fd: 0x0024, 0x17fe: 0x0024, 0x17ff: 0x0024, // Block 0x60, offset 0x1800 - 0x1819: 0x0004, 0x181a: 0x0004, + 0x182a: 0x0024, 0x182b: 0x0024, 0x182c: 0x0024, 0x182d: 0x0024, 0x182e: 0x0024, 0x182f: 0x0024, + 0x1830: 0x0008, + 0x183d: 0x0008, // Block 0x61, offset 0x1840 - 0x1857: 0x0008, - 0x1859: 0x0008, + 0x1859: 0x0024, 0x185a: 0x0024, // Block 0x62, offset 0x1880 - 0x18af: 0x0004, - 0x18b0: 0x0004, 0x18b1: 0x0004, 0x18b2: 0x0004, 0x18b4: 0x0004, 0x18b5: 0x0004, - 0x18b6: 0x0004, 0x18b7: 0x0004, 0x18b8: 0x0004, 0x18b9: 0x0004, 0x18ba: 0x0004, 0x18bb: 0x0004, - 0x18bc: 0x0004, 0x18bd: 0x0004, + 0x1897: 0x0008, + 0x1899: 0x0008, // Block 0x63, offset 0x18c0 - 0x18de: 0x0004, 0x18df: 0x0004, + 0x18ef: 0x0024, + 0x18f0: 0x0024, 0x18f1: 0x0024, 0x18f2: 0x0024, 0x18f4: 0x0024, 0x18f5: 0x0024, + 0x18f6: 0x0024, 0x18f7: 0x0024, 0x18f8: 0x0024, 0x18f9: 0x0024, 0x18fa: 0x0024, 0x18fb: 0x0024, + 0x18fc: 0x0024, 0x18fd: 0x0024, // Block 0x64, offset 0x1900 - 0x1930: 0x0004, 0x1931: 0x0004, + 0x191e: 0x0024, 0x191f: 0x0024, // Block 0x65, offset 0x1940 - 0x1942: 0x0004, - 0x1946: 0x0004, 0x194b: 0x0004, - 0x1963: 0x0400, - 0x1964: 0x0400, 0x1965: 0x0004, 0x1966: 0x0004, 0x1967: 0x0400, - 0x196c: 0x0004, + 0x1970: 0x0024, 0x1971: 0x0024, // Block 0x66, offset 0x1980 - 0x1980: 0x0400, 0x1981: 0x0400, - 0x19b4: 0x0400, 0x19b5: 0x0400, - 0x19b6: 0x0400, 0x19b7: 0x0400, 0x19b8: 0x0400, 0x19b9: 0x0400, 0x19ba: 0x0400, 0x19bb: 0x0400, - 0x19bc: 0x0400, 0x19bd: 0x0400, 0x19be: 0x0400, 0x19bf: 0x0400, + 0x1982: 0x0024, + 0x1986: 0x0024, 0x198b: 0x0024, + 0x19a3: 0x2000, + 0x19a4: 0x2000, 0x19a5: 0x0024, 0x19a6: 0x0024, 0x19a7: 0x2000, + 0x19ac: 0x0024, // Block 0x67, offset 0x19c0 - 0x19c0: 0x0400, 0x19c1: 0x0400, 0x19c2: 0x0400, 0x19c3: 0x0400, 0x19c4: 0x0004, 0x19c5: 0x0004, - 0x19e0: 0x0004, 0x19e1: 0x0004, 0x19e2: 0x0004, 0x19e3: 0x0004, - 0x19e4: 0x0004, 0x19e5: 0x0004, 0x19e6: 0x0004, 0x19e7: 0x0004, 0x19e8: 0x0004, 0x19e9: 0x0004, - 0x19ea: 0x0004, 0x19eb: 0x0004, 0x19ec: 0x0004, 0x19ed: 0x0004, 0x19ee: 0x0004, 0x19ef: 0x0004, - 0x19f0: 0x0004, 0x19f1: 0x0004, - 0x19ff: 0x0004, + 0x19c0: 0x2000, 0x19c1: 0x2000, + 0x19f4: 0x2000, 0x19f5: 0x2000, + 0x19f6: 0x2000, 0x19f7: 0x2000, 0x19f8: 0x2000, 0x19f9: 0x2000, 0x19fa: 0x2000, 0x19fb: 0x2000, + 0x19fc: 0x2000, 0x19fd: 0x2000, 0x19fe: 0x2000, 0x19ff: 0x2000, // Block 0x68, offset 0x1a00 - 0x1a26: 0x0004, 0x1a27: 0x0004, 0x1a28: 0x0004, 0x1a29: 0x0004, - 0x1a2a: 0x0004, 0x1a2b: 0x0004, 0x1a2c: 0x0004, 0x1a2d: 0x0004, + 0x1a00: 0x2000, 0x1a01: 0x2000, 0x1a02: 0x2000, 0x1a03: 0x2000, 0x1a04: 0x0024, 0x1a05: 0x0024, + 0x1a20: 0x0024, 0x1a21: 0x0024, 0x1a22: 0x0024, 0x1a23: 0x0024, + 0x1a24: 0x0024, 0x1a25: 0x0024, 0x1a26: 0x0024, 0x1a27: 0x0024, 0x1a28: 0x0024, 0x1a29: 0x0024, + 0x1a2a: 0x0024, 0x1a2b: 0x0024, 0x1a2c: 0x0024, 0x1a2d: 0x0024, 0x1a2e: 0x0024, 0x1a2f: 0x0024, + 0x1a30: 0x0024, 0x1a31: 0x0024, + 0x1a3f: 0x0024, // Block 0x69, offset 0x1a40 - 0x1a47: 0x0004, 0x1a48: 0x0004, 0x1a49: 0x0004, 0x1a4a: 0x0004, 0x1a4b: 0x0004, - 0x1a4c: 0x0004, 0x1a4d: 0x0004, 0x1a4e: 0x0004, 0x1a4f: 0x0004, 0x1a50: 0x0004, 0x1a51: 0x0004, - 0x1a52: 0x0400, 0x1a53: 0x0400, - 0x1a60: 0x0010, 0x1a61: 0x0010, 0x1a62: 0x0010, 0x1a63: 0x0010, - 0x1a64: 0x0010, 0x1a65: 0x0010, 0x1a66: 0x0010, 0x1a67: 0x0010, 0x1a68: 0x0010, 0x1a69: 0x0010, - 0x1a6a: 0x0010, 0x1a6b: 0x0010, 0x1a6c: 0x0010, 0x1a6d: 0x0010, 0x1a6e: 0x0010, 0x1a6f: 0x0010, - 0x1a70: 0x0010, 0x1a71: 0x0010, 0x1a72: 0x0010, 0x1a73: 0x0010, 0x1a74: 0x0010, 0x1a75: 0x0010, - 0x1a76: 0x0010, 0x1a77: 0x0010, 0x1a78: 0x0010, 0x1a79: 0x0010, 0x1a7a: 0x0010, 0x1a7b: 0x0010, - 0x1a7c: 0x0010, + 0x1a66: 0x0024, 0x1a67: 0x0024, 0x1a68: 0x0024, 0x1a69: 0x0024, + 0x1a6a: 0x0024, 0x1a6b: 0x0024, 0x1a6c: 0x0024, 0x1a6d: 0x0024, // Block 0x6a, offset 0x1a80 - 0x1a80: 0x0004, 0x1a81: 0x0004, 0x1a82: 0x0004, 0x1a83: 0x0400, - 0x1ab3: 0x0004, 0x1ab4: 0x0400, 0x1ab5: 0x0400, - 0x1ab6: 0x0004, 0x1ab7: 0x0004, 0x1ab8: 0x0004, 0x1ab9: 0x0004, 0x1aba: 0x0400, 0x1abb: 0x0400, - 0x1abc: 0x0004, 0x1abd: 0x0004, 0x1abe: 0x0400, 0x1abf: 0x0400, + 0x1a87: 0x0024, 0x1a88: 0x0024, 0x1a89: 0x0024, 0x1a8a: 0x0024, 0x1a8b: 0x0024, + 0x1a8c: 0x0024, 0x1a8d: 0x0024, 0x1a8e: 0x0024, 0x1a8f: 0x0024, 0x1a90: 0x0024, 0x1a91: 0x0024, + 0x1a92: 0x2000, 0x1a93: 0x0024, + 0x1aa0: 0x0080, 0x1aa1: 0x0080, 0x1aa2: 0x0080, 0x1aa3: 0x0080, + 0x1aa4: 0x0080, 0x1aa5: 0x0080, 0x1aa6: 0x0080, 0x1aa7: 0x0080, 0x1aa8: 0x0080, 0x1aa9: 0x0080, + 0x1aaa: 0x0080, 0x1aab: 0x0080, 0x1aac: 0x0080, 0x1aad: 0x0080, 0x1aae: 0x0080, 0x1aaf: 0x0080, + 0x1ab0: 0x0080, 0x1ab1: 0x0080, 0x1ab2: 0x0080, 0x1ab3: 0x0080, 0x1ab4: 0x0080, 0x1ab5: 0x0080, + 0x1ab6: 0x0080, 0x1ab7: 0x0080, 0x1ab8: 0x0080, 0x1ab9: 0x0080, 0x1aba: 0x0080, 0x1abb: 0x0080, + 0x1abc: 0x0080, // Block 0x6b, offset 0x1ac0 - 0x1ac0: 0x0400, - 0x1ae5: 0x0004, + 0x1ac0: 0x0024, 0x1ac1: 0x0024, 0x1ac2: 0x0024, 0x1ac3: 0x2000, + 0x1ac9: 0x0010, 0x1aca: 0x0010, 0x1acb: 0x0010, + 0x1acf: 0x0010, 0x1ad0: 0x0010, 0x1ad1: 0x0010, + 0x1ad2: 0x0010, 0x1ad3: 0x0010, 0x1ad4: 0x0010, 0x1ad5: 0x0010, 0x1ad6: 0x0010, 0x1ad7: 0x0010, + 0x1ad8: 0x0010, 0x1ad9: 0x0010, 0x1ada: 0x0010, 0x1adb: 0x0010, 0x1adc: 0x0010, 0x1add: 0x0010, + 0x1ade: 0x0010, 0x1adf: 0x0010, 0x1ae0: 0x0010, 0x1ae1: 0x0010, 0x1ae2: 0x0010, 0x1ae3: 0x0010, + 0x1ae4: 0x0010, 0x1ae5: 0x0010, 0x1ae6: 0x0010, 0x1ae7: 0x0010, 0x1ae8: 0x0010, 0x1ae9: 0x0010, + 0x1aea: 0x0010, 0x1aeb: 0x0010, 0x1aec: 0x0010, 0x1aed: 0x0010, 0x1aee: 0x0010, 0x1aef: 0x0010, + 0x1af0: 0x0010, 0x1af1: 0x0010, 0x1af2: 0x0010, 0x1af3: 0x0024, 0x1af4: 0x2000, 0x1af5: 0x2000, + 0x1af6: 0x0024, 0x1af7: 0x0024, 0x1af8: 0x0024, 0x1af9: 0x0024, 0x1afa: 0x2000, 0x1afb: 0x2000, + 0x1afc: 0x0024, 0x1afd: 0x0024, 0x1afe: 0x2000, 0x1aff: 0x2000, // Block 0x6c, offset 0x1b00 - 0x1b29: 0x0004, - 0x1b2a: 0x0004, 0x1b2b: 0x0004, 0x1b2c: 0x0004, 0x1b2d: 0x0004, 0x1b2e: 0x0004, 0x1b2f: 0x0400, - 0x1b30: 0x0400, 0x1b31: 0x0004, 0x1b32: 0x0004, 0x1b33: 0x0400, 0x1b34: 0x0400, 0x1b35: 0x0004, - 0x1b36: 0x0004, + 0x1b00: 0x0044, + 0x1b20: 0x0010, 0x1b21: 0x0010, 0x1b22: 0x0010, 0x1b23: 0x0010, + 0x1b24: 0x0010, 0x1b25: 0x0024, 0x1b27: 0x0010, 0x1b28: 0x0010, 0x1b29: 0x0010, + 0x1b2a: 0x0010, 0x1b2b: 0x0010, 0x1b2c: 0x0010, 0x1b2d: 0x0010, 0x1b2e: 0x0010, 0x1b2f: 0x0010, + 0x1b3a: 0x0010, 0x1b3b: 0x0010, + 0x1b3c: 0x0010, 0x1b3d: 0x0010, 0x1b3e: 0x0010, // Block 0x6d, offset 0x1b40 - 0x1b43: 0x0004, - 0x1b4c: 0x0004, 0x1b4d: 0x0400, - 0x1b7c: 0x0004, + 0x1b69: 0x0024, + 0x1b6a: 0x0024, 0x1b6b: 0x0024, 0x1b6c: 0x0024, 0x1b6d: 0x0024, 0x1b6e: 0x0024, 0x1b6f: 0x2000, + 0x1b70: 0x2000, 0x1b71: 0x0024, 0x1b72: 0x0024, 0x1b73: 0x2000, 0x1b74: 0x2000, 0x1b75: 0x0024, + 0x1b76: 0x0024, // Block 0x6e, offset 0x1b80 - 0x1bb0: 0x0004, 0x1bb2: 0x0004, 0x1bb3: 0x0004, 0x1bb4: 0x0004, - 0x1bb7: 0x0004, 0x1bb8: 0x0004, - 0x1bbe: 0x0004, 0x1bbf: 0x0004, + 0x1b83: 0x0024, + 0x1b8c: 0x0024, 0x1b8d: 0x2000, + 0x1ba0: 0x0010, 0x1ba1: 0x0010, 0x1ba2: 0x0010, 0x1ba3: 0x0010, + 0x1ba4: 0x0010, 0x1ba5: 0x0010, 0x1ba6: 0x0010, 0x1ba7: 0x0010, 0x1ba8: 0x0010, 0x1ba9: 0x0010, + 0x1baa: 0x0010, 0x1bab: 0x0010, 0x1bac: 0x0010, 0x1bad: 0x0010, 0x1bae: 0x0010, 0x1baf: 0x0010, + 0x1bb1: 0x0010, 0x1bb2: 0x0010, 0x1bb3: 0x0010, + 0x1bba: 0x0010, + 0x1bbc: 0x0024, 0x1bbe: 0x0010, 0x1bbf: 0x0010, // Block 0x6f, offset 0x1bc0 - 0x1bc1: 0x0004, - 0x1beb: 0x0400, 0x1bec: 0x0004, 0x1bed: 0x0004, 0x1bee: 0x0400, 0x1bef: 0x0400, - 0x1bf5: 0x0400, - 0x1bf6: 0x0004, + 0x1bf0: 0x0024, 0x1bf2: 0x0024, 0x1bf3: 0x0024, 0x1bf4: 0x0024, + 0x1bf7: 0x0024, 0x1bf8: 0x0024, + 0x1bfe: 0x0024, 0x1bff: 0x0024, // Block 0x70, offset 0x1c00 - 0x1c23: 0x0400, - 0x1c24: 0x0400, 0x1c25: 0x0004, 0x1c26: 0x0400, 0x1c27: 0x0400, 0x1c28: 0x0004, 0x1c29: 0x0400, - 0x1c2a: 0x0400, 0x1c2c: 0x0400, 0x1c2d: 0x0004, + 0x1c01: 0x0024, + 0x1c20: 0x0010, 0x1c21: 0x0010, 0x1c22: 0x0010, 0x1c23: 0x0010, + 0x1c24: 0x0010, 0x1c25: 0x0010, 0x1c26: 0x0010, 0x1c27: 0x0010, 0x1c28: 0x0010, 0x1c29: 0x0010, + 0x1c2a: 0x0010, 0x1c2b: 0x2000, 0x1c2c: 0x0024, 0x1c2d: 0x0024, 0x1c2e: 0x2000, 0x1c2f: 0x2000, + 0x1c35: 0x2000, + 0x1c36: 0x0044, // Block 0x71, offset 0x1c40 - 0x1c40: 0x0040, 0x1c41: 0x0080, 0x1c42: 0x0080, 0x1c43: 0x0080, 0x1c44: 0x0080, 0x1c45: 0x0080, - 0x1c46: 0x0080, 0x1c47: 0x0080, 0x1c48: 0x0080, 0x1c49: 0x0080, 0x1c4a: 0x0080, 0x1c4b: 0x0080, - 0x1c4c: 0x0080, 0x1c4d: 0x0080, 0x1c4e: 0x0080, 0x1c4f: 0x0080, 0x1c50: 0x0080, 0x1c51: 0x0080, - 0x1c52: 0x0080, 0x1c53: 0x0080, 0x1c54: 0x0080, 0x1c55: 0x0080, 0x1c56: 0x0080, 0x1c57: 0x0080, - 0x1c58: 0x0080, 0x1c59: 0x0080, 0x1c5a: 0x0080, 0x1c5b: 0x0080, 0x1c5c: 0x0040, 0x1c5d: 0x0080, - 0x1c5e: 0x0080, 0x1c5f: 0x0080, 0x1c60: 0x0080, 0x1c61: 0x0080, 0x1c62: 0x0080, 0x1c63: 0x0080, - 0x1c64: 0x0080, 0x1c65: 0x0080, 0x1c66: 0x0080, 0x1c67: 0x0080, 0x1c68: 0x0080, 0x1c69: 0x0080, - 0x1c6a: 0x0080, 0x1c6b: 0x0080, 0x1c6c: 0x0080, 0x1c6d: 0x0080, 0x1c6e: 0x0080, 0x1c6f: 0x0080, - 0x1c70: 0x0080, 0x1c71: 0x0080, 0x1c72: 0x0080, 0x1c73: 0x0080, 0x1c74: 0x0080, 0x1c75: 0x0080, - 0x1c76: 0x0080, 0x1c77: 0x0080, 0x1c78: 0x0040, 0x1c79: 0x0080, 0x1c7a: 0x0080, 0x1c7b: 0x0080, - 0x1c7c: 0x0080, 0x1c7d: 0x0080, 0x1c7e: 0x0080, 0x1c7f: 0x0080, + 0x1c40: 0x0010, 0x1c41: 0x0010, 0x1c42: 0x0010, 0x1c43: 0x0010, 0x1c44: 0x0010, 0x1c45: 0x0010, + 0x1c46: 0x0010, 0x1c47: 0x0010, 0x1c48: 0x0010, 0x1c49: 0x0010, 0x1c4a: 0x0010, 0x1c4b: 0x0010, + 0x1c4c: 0x0010, 0x1c4d: 0x0010, 0x1c4e: 0x0010, 0x1c4f: 0x0010, 0x1c50: 0x0010, 0x1c51: 0x0010, + 0x1c52: 0x0010, 0x1c53: 0x0010, 0x1c54: 0x0010, 0x1c55: 0x0010, 0x1c56: 0x0010, 0x1c57: 0x0010, + 0x1c58: 0x0010, 0x1c59: 0x0010, 0x1c5a: 0x0010, + 0x1c63: 0x2000, + 0x1c64: 0x2000, 0x1c65: 0x0024, 0x1c66: 0x2000, 0x1c67: 0x2000, 0x1c68: 0x0024, 0x1c69: 0x2000, + 0x1c6a: 0x2000, 0x1c6c: 0x2000, 0x1c6d: 0x0024, // Block 0x72, offset 0x1c80 - 0x1c80: 0x0080, 0x1c81: 0x0080, 0x1c82: 0x0080, 0x1c83: 0x0080, 0x1c84: 0x0080, 0x1c85: 0x0080, - 0x1c86: 0x0080, 0x1c87: 0x0080, 0x1c88: 0x0080, 0x1c89: 0x0080, 0x1c8a: 0x0080, 0x1c8b: 0x0080, - 0x1c8c: 0x0080, 0x1c8d: 0x0080, 0x1c8e: 0x0080, 0x1c8f: 0x0080, 0x1c90: 0x0080, 0x1c91: 0x0080, - 0x1c92: 0x0080, 0x1c93: 0x0080, 0x1c94: 0x0040, 0x1c95: 0x0080, 0x1c96: 0x0080, 0x1c97: 0x0080, - 0x1c98: 0x0080, 0x1c99: 0x0080, 0x1c9a: 0x0080, 0x1c9b: 0x0080, 0x1c9c: 0x0080, 0x1c9d: 0x0080, - 0x1c9e: 0x0080, 0x1c9f: 0x0080, 0x1ca0: 0x0080, 0x1ca1: 0x0080, 0x1ca2: 0x0080, 0x1ca3: 0x0080, - 0x1ca4: 0x0080, 0x1ca5: 0x0080, 0x1ca6: 0x0080, 0x1ca7: 0x0080, 0x1ca8: 0x0080, 0x1ca9: 0x0080, - 0x1caa: 0x0080, 0x1cab: 0x0080, 0x1cac: 0x0080, 0x1cad: 0x0080, 0x1cae: 0x0080, 0x1caf: 0x0080, - 0x1cb0: 0x0040, 0x1cb1: 0x0080, 0x1cb2: 0x0080, 0x1cb3: 0x0080, 0x1cb4: 0x0080, 0x1cb5: 0x0080, - 0x1cb6: 0x0080, 0x1cb7: 0x0080, 0x1cb8: 0x0080, 0x1cb9: 0x0080, 0x1cba: 0x0080, 0x1cbb: 0x0080, - 0x1cbc: 0x0080, 0x1cbd: 0x0080, 0x1cbe: 0x0080, 0x1cbf: 0x0080, + 0x1c80: 0x0200, 0x1c81: 0x0400, 0x1c82: 0x0400, 0x1c83: 0x0400, 0x1c84: 0x0400, 0x1c85: 0x0400, + 0x1c86: 0x0400, 0x1c87: 0x0400, 0x1c88: 0x0400, 0x1c89: 0x0400, 0x1c8a: 0x0400, 0x1c8b: 0x0400, + 0x1c8c: 0x0400, 0x1c8d: 0x0400, 0x1c8e: 0x0400, 0x1c8f: 0x0400, 0x1c90: 0x0400, 0x1c91: 0x0400, + 0x1c92: 0x0400, 0x1c93: 0x0400, 0x1c94: 0x0400, 0x1c95: 0x0400, 0x1c96: 0x0400, 0x1c97: 0x0400, + 0x1c98: 0x0400, 0x1c99: 0x0400, 0x1c9a: 0x0400, 0x1c9b: 0x0400, 0x1c9c: 0x0200, 0x1c9d: 0x0400, + 0x1c9e: 0x0400, 0x1c9f: 0x0400, 0x1ca0: 0x0400, 0x1ca1: 0x0400, 0x1ca2: 0x0400, 0x1ca3: 0x0400, + 0x1ca4: 0x0400, 0x1ca5: 0x0400, 0x1ca6: 0x0400, 0x1ca7: 0x0400, 0x1ca8: 0x0400, 0x1ca9: 0x0400, + 0x1caa: 0x0400, 0x1cab: 0x0400, 0x1cac: 0x0400, 0x1cad: 0x0400, 0x1cae: 0x0400, 0x1caf: 0x0400, + 0x1cb0: 0x0400, 0x1cb1: 0x0400, 0x1cb2: 0x0400, 0x1cb3: 0x0400, 0x1cb4: 0x0400, 0x1cb5: 0x0400, + 0x1cb6: 0x0400, 0x1cb7: 0x0400, 0x1cb8: 0x0200, 0x1cb9: 0x0400, 0x1cba: 0x0400, 0x1cbb: 0x0400, + 0x1cbc: 0x0400, 0x1cbd: 0x0400, 0x1cbe: 0x0400, 0x1cbf: 0x0400, // Block 0x73, offset 0x1cc0 - 0x1cc0: 0x0080, 0x1cc1: 0x0080, 0x1cc2: 0x0080, 0x1cc3: 0x0080, 0x1cc4: 0x0080, 0x1cc5: 0x0080, - 0x1cc6: 0x0080, 0x1cc7: 0x0080, 0x1cc8: 0x0080, 0x1cc9: 0x0080, 0x1cca: 0x0080, 0x1ccb: 0x0080, - 0x1ccc: 0x0040, 0x1ccd: 0x0080, 0x1cce: 0x0080, 0x1ccf: 0x0080, 0x1cd0: 0x0080, 0x1cd1: 0x0080, - 0x1cd2: 0x0080, 0x1cd3: 0x0080, 0x1cd4: 0x0080, 0x1cd5: 0x0080, 0x1cd6: 0x0080, 0x1cd7: 0x0080, - 0x1cd8: 0x0080, 0x1cd9: 0x0080, 0x1cda: 0x0080, 0x1cdb: 0x0080, 0x1cdc: 0x0080, 0x1cdd: 0x0080, - 0x1cde: 0x0080, 0x1cdf: 0x0080, 0x1ce0: 0x0080, 0x1ce1: 0x0080, 0x1ce2: 0x0080, 0x1ce3: 0x0080, - 0x1ce4: 0x0080, 0x1ce5: 0x0080, 0x1ce6: 0x0080, 0x1ce7: 0x0080, 0x1ce8: 0x0040, 0x1ce9: 0x0080, - 0x1cea: 0x0080, 0x1ceb: 0x0080, 0x1cec: 0x0080, 0x1ced: 0x0080, 0x1cee: 0x0080, 0x1cef: 0x0080, - 0x1cf0: 0x0080, 0x1cf1: 0x0080, 0x1cf2: 0x0080, 0x1cf3: 0x0080, 0x1cf4: 0x0080, 0x1cf5: 0x0080, - 0x1cf6: 0x0080, 0x1cf7: 0x0080, 0x1cf8: 0x0080, 0x1cf9: 0x0080, 0x1cfa: 0x0080, 0x1cfb: 0x0080, - 0x1cfc: 0x0080, 0x1cfd: 0x0080, 0x1cfe: 0x0080, 0x1cff: 0x0080, + 0x1cc0: 0x0400, 0x1cc1: 0x0400, 0x1cc2: 0x0400, 0x1cc3: 0x0400, 0x1cc4: 0x0400, 0x1cc5: 0x0400, + 0x1cc6: 0x0400, 0x1cc7: 0x0400, 0x1cc8: 0x0400, 0x1cc9: 0x0400, 0x1cca: 0x0400, 0x1ccb: 0x0400, + 0x1ccc: 0x0400, 0x1ccd: 0x0400, 0x1cce: 0x0400, 0x1ccf: 0x0400, 0x1cd0: 0x0400, 0x1cd1: 0x0400, + 0x1cd2: 0x0400, 0x1cd3: 0x0400, 0x1cd4: 0x0200, 0x1cd5: 0x0400, 0x1cd6: 0x0400, 0x1cd7: 0x0400, + 0x1cd8: 0x0400, 0x1cd9: 0x0400, 0x1cda: 0x0400, 0x1cdb: 0x0400, 0x1cdc: 0x0400, 0x1cdd: 0x0400, + 0x1cde: 0x0400, 0x1cdf: 0x0400, 0x1ce0: 0x0400, 0x1ce1: 0x0400, 0x1ce2: 0x0400, 0x1ce3: 0x0400, + 0x1ce4: 0x0400, 0x1ce5: 0x0400, 0x1ce6: 0x0400, 0x1ce7: 0x0400, 0x1ce8: 0x0400, 0x1ce9: 0x0400, + 0x1cea: 0x0400, 0x1ceb: 0x0400, 0x1cec: 0x0400, 0x1ced: 0x0400, 0x1cee: 0x0400, 0x1cef: 0x0400, + 0x1cf0: 0x0200, 0x1cf1: 0x0400, 0x1cf2: 0x0400, 0x1cf3: 0x0400, 0x1cf4: 0x0400, 0x1cf5: 0x0400, + 0x1cf6: 0x0400, 0x1cf7: 0x0400, 0x1cf8: 0x0400, 0x1cf9: 0x0400, 0x1cfa: 0x0400, 0x1cfb: 0x0400, + 0x1cfc: 0x0400, 0x1cfd: 0x0400, 0x1cfe: 0x0400, 0x1cff: 0x0400, // Block 0x74, offset 0x1d00 - 0x1d00: 0x0080, 0x1d01: 0x0080, 0x1d02: 0x0080, 0x1d03: 0x0080, 0x1d04: 0x0040, 0x1d05: 0x0080, - 0x1d06: 0x0080, 0x1d07: 0x0080, 0x1d08: 0x0080, 0x1d09: 0x0080, 0x1d0a: 0x0080, 0x1d0b: 0x0080, - 0x1d0c: 0x0080, 0x1d0d: 0x0080, 0x1d0e: 0x0080, 0x1d0f: 0x0080, 0x1d10: 0x0080, 0x1d11: 0x0080, - 0x1d12: 0x0080, 0x1d13: 0x0080, 0x1d14: 0x0080, 0x1d15: 0x0080, 0x1d16: 0x0080, 0x1d17: 0x0080, - 0x1d18: 0x0080, 0x1d19: 0x0080, 0x1d1a: 0x0080, 0x1d1b: 0x0080, 0x1d1c: 0x0080, 0x1d1d: 0x0080, - 0x1d1e: 0x0080, 0x1d1f: 0x0080, 0x1d20: 0x0040, 0x1d21: 0x0080, 0x1d22: 0x0080, 0x1d23: 0x0080, - 0x1d24: 0x0080, 0x1d25: 0x0080, 0x1d26: 0x0080, 0x1d27: 0x0080, 0x1d28: 0x0080, 0x1d29: 0x0080, - 0x1d2a: 0x0080, 0x1d2b: 0x0080, 0x1d2c: 0x0080, 0x1d2d: 0x0080, 0x1d2e: 0x0080, 0x1d2f: 0x0080, - 0x1d30: 0x0080, 0x1d31: 0x0080, 0x1d32: 0x0080, 0x1d33: 0x0080, 0x1d34: 0x0080, 0x1d35: 0x0080, - 0x1d36: 0x0080, 0x1d37: 0x0080, 0x1d38: 0x0080, 0x1d39: 0x0080, 0x1d3a: 0x0080, 0x1d3b: 0x0080, - 0x1d3c: 0x0040, 0x1d3d: 0x0080, 0x1d3e: 0x0080, 0x1d3f: 0x0080, + 0x1d00: 0x0400, 0x1d01: 0x0400, 0x1d02: 0x0400, 0x1d03: 0x0400, 0x1d04: 0x0400, 0x1d05: 0x0400, + 0x1d06: 0x0400, 0x1d07: 0x0400, 0x1d08: 0x0400, 0x1d09: 0x0400, 0x1d0a: 0x0400, 0x1d0b: 0x0400, + 0x1d0c: 0x0200, 0x1d0d: 0x0400, 0x1d0e: 0x0400, 0x1d0f: 0x0400, 0x1d10: 0x0400, 0x1d11: 0x0400, + 0x1d12: 0x0400, 0x1d13: 0x0400, 0x1d14: 0x0400, 0x1d15: 0x0400, 0x1d16: 0x0400, 0x1d17: 0x0400, + 0x1d18: 0x0400, 0x1d19: 0x0400, 0x1d1a: 0x0400, 0x1d1b: 0x0400, 0x1d1c: 0x0400, 0x1d1d: 0x0400, + 0x1d1e: 0x0400, 0x1d1f: 0x0400, 0x1d20: 0x0400, 0x1d21: 0x0400, 0x1d22: 0x0400, 0x1d23: 0x0400, + 0x1d24: 0x0400, 0x1d25: 0x0400, 0x1d26: 0x0400, 0x1d27: 0x0400, 0x1d28: 0x0200, 0x1d29: 0x0400, + 0x1d2a: 0x0400, 0x1d2b: 0x0400, 0x1d2c: 0x0400, 0x1d2d: 0x0400, 0x1d2e: 0x0400, 0x1d2f: 0x0400, + 0x1d30: 0x0400, 0x1d31: 0x0400, 0x1d32: 0x0400, 0x1d33: 0x0400, 0x1d34: 0x0400, 0x1d35: 0x0400, + 0x1d36: 0x0400, 0x1d37: 0x0400, 0x1d38: 0x0400, 0x1d39: 0x0400, 0x1d3a: 0x0400, 0x1d3b: 0x0400, + 0x1d3c: 0x0400, 0x1d3d: 0x0400, 0x1d3e: 0x0400, 0x1d3f: 0x0400, // Block 0x75, offset 0x1d40 - 0x1d40: 0x0080, 0x1d41: 0x0080, 0x1d42: 0x0080, 0x1d43: 0x0080, 0x1d44: 0x0080, 0x1d45: 0x0080, - 0x1d46: 0x0080, 0x1d47: 0x0080, 0x1d48: 0x0080, 0x1d49: 0x0080, 0x1d4a: 0x0080, 0x1d4b: 0x0080, - 0x1d4c: 0x0080, 0x1d4d: 0x0080, 0x1d4e: 0x0080, 0x1d4f: 0x0080, 0x1d50: 0x0080, 0x1d51: 0x0080, - 0x1d52: 0x0080, 0x1d53: 0x0080, 0x1d54: 0x0080, 0x1d55: 0x0080, 0x1d56: 0x0080, 0x1d57: 0x0080, - 0x1d58: 0x0040, 0x1d59: 0x0080, 0x1d5a: 0x0080, 0x1d5b: 0x0080, 0x1d5c: 0x0080, 0x1d5d: 0x0080, - 0x1d5e: 0x0080, 0x1d5f: 0x0080, 0x1d60: 0x0080, 0x1d61: 0x0080, 0x1d62: 0x0080, 0x1d63: 0x0080, - 0x1d64: 0x0080, 0x1d65: 0x0080, 0x1d66: 0x0080, 0x1d67: 0x0080, 0x1d68: 0x0080, 0x1d69: 0x0080, - 0x1d6a: 0x0080, 0x1d6b: 0x0080, 0x1d6c: 0x0080, 0x1d6d: 0x0080, 0x1d6e: 0x0080, 0x1d6f: 0x0080, - 0x1d70: 0x0080, 0x1d71: 0x0080, 0x1d72: 0x0080, 0x1d73: 0x0080, 0x1d74: 0x0040, 0x1d75: 0x0080, - 0x1d76: 0x0080, 0x1d77: 0x0080, 0x1d78: 0x0080, 0x1d79: 0x0080, 0x1d7a: 0x0080, 0x1d7b: 0x0080, - 0x1d7c: 0x0080, 0x1d7d: 0x0080, 0x1d7e: 0x0080, 0x1d7f: 0x0080, + 0x1d40: 0x0400, 0x1d41: 0x0400, 0x1d42: 0x0400, 0x1d43: 0x0400, 0x1d44: 0x0200, 0x1d45: 0x0400, + 0x1d46: 0x0400, 0x1d47: 0x0400, 0x1d48: 0x0400, 0x1d49: 0x0400, 0x1d4a: 0x0400, 0x1d4b: 0x0400, + 0x1d4c: 0x0400, 0x1d4d: 0x0400, 0x1d4e: 0x0400, 0x1d4f: 0x0400, 0x1d50: 0x0400, 0x1d51: 0x0400, + 0x1d52: 0x0400, 0x1d53: 0x0400, 0x1d54: 0x0400, 0x1d55: 0x0400, 0x1d56: 0x0400, 0x1d57: 0x0400, + 0x1d58: 0x0400, 0x1d59: 0x0400, 0x1d5a: 0x0400, 0x1d5b: 0x0400, 0x1d5c: 0x0400, 0x1d5d: 0x0400, + 0x1d5e: 0x0400, 0x1d5f: 0x0400, 0x1d60: 0x0200, 0x1d61: 0x0400, 0x1d62: 0x0400, 0x1d63: 0x0400, + 0x1d64: 0x0400, 0x1d65: 0x0400, 0x1d66: 0x0400, 0x1d67: 0x0400, 0x1d68: 0x0400, 0x1d69: 0x0400, + 0x1d6a: 0x0400, 0x1d6b: 0x0400, 0x1d6c: 0x0400, 0x1d6d: 0x0400, 0x1d6e: 0x0400, 0x1d6f: 0x0400, + 0x1d70: 0x0400, 0x1d71: 0x0400, 0x1d72: 0x0400, 0x1d73: 0x0400, 0x1d74: 0x0400, 0x1d75: 0x0400, + 0x1d76: 0x0400, 0x1d77: 0x0400, 0x1d78: 0x0400, 0x1d79: 0x0400, 0x1d7a: 0x0400, 0x1d7b: 0x0400, + 0x1d7c: 0x0200, 0x1d7d: 0x0400, 0x1d7e: 0x0400, 0x1d7f: 0x0400, // Block 0x76, offset 0x1d80 - 0x1d80: 0x0080, 0x1d81: 0x0080, 0x1d82: 0x0080, 0x1d83: 0x0080, 0x1d84: 0x0080, 0x1d85: 0x0080, - 0x1d86: 0x0080, 0x1d87: 0x0080, 0x1d88: 0x0080, 0x1d89: 0x0080, 0x1d8a: 0x0080, 0x1d8b: 0x0080, - 0x1d8c: 0x0080, 0x1d8d: 0x0080, 0x1d8e: 0x0080, 0x1d8f: 0x0080, 0x1d90: 0x0040, 0x1d91: 0x0080, - 0x1d92: 0x0080, 0x1d93: 0x0080, 0x1d94: 0x0080, 0x1d95: 0x0080, 0x1d96: 0x0080, 0x1d97: 0x0080, - 0x1d98: 0x0080, 0x1d99: 0x0080, 0x1d9a: 0x0080, 0x1d9b: 0x0080, 0x1d9c: 0x0080, 0x1d9d: 0x0080, - 0x1d9e: 0x0080, 0x1d9f: 0x0080, 0x1da0: 0x0080, 0x1da1: 0x0080, 0x1da2: 0x0080, 0x1da3: 0x0080, - 0x1da4: 0x0080, 0x1da5: 0x0080, 0x1da6: 0x0080, 0x1da7: 0x0080, 0x1da8: 0x0080, 0x1da9: 0x0080, - 0x1daa: 0x0080, 0x1dab: 0x0080, 0x1dac: 0x0040, 0x1dad: 0x0080, 0x1dae: 0x0080, 0x1daf: 0x0080, - 0x1db0: 0x0080, 0x1db1: 0x0080, 0x1db2: 0x0080, 0x1db3: 0x0080, 0x1db4: 0x0080, 0x1db5: 0x0080, - 0x1db6: 0x0080, 0x1db7: 0x0080, 0x1db8: 0x0080, 0x1db9: 0x0080, 0x1dba: 0x0080, 0x1dbb: 0x0080, - 0x1dbc: 0x0080, 0x1dbd: 0x0080, 0x1dbe: 0x0080, 0x1dbf: 0x0080, + 0x1d80: 0x0400, 0x1d81: 0x0400, 0x1d82: 0x0400, 0x1d83: 0x0400, 0x1d84: 0x0400, 0x1d85: 0x0400, + 0x1d86: 0x0400, 0x1d87: 0x0400, 0x1d88: 0x0400, 0x1d89: 0x0400, 0x1d8a: 0x0400, 0x1d8b: 0x0400, + 0x1d8c: 0x0400, 0x1d8d: 0x0400, 0x1d8e: 0x0400, 0x1d8f: 0x0400, 0x1d90: 0x0400, 0x1d91: 0x0400, + 0x1d92: 0x0400, 0x1d93: 0x0400, 0x1d94: 0x0400, 0x1d95: 0x0400, 0x1d96: 0x0400, 0x1d97: 0x0400, + 0x1d98: 0x0200, 0x1d99: 0x0400, 0x1d9a: 0x0400, 0x1d9b: 0x0400, 0x1d9c: 0x0400, 0x1d9d: 0x0400, + 0x1d9e: 0x0400, 0x1d9f: 0x0400, 0x1da0: 0x0400, 0x1da1: 0x0400, 0x1da2: 0x0400, 0x1da3: 0x0400, + 0x1da4: 0x0400, 0x1da5: 0x0400, 0x1da6: 0x0400, 0x1da7: 0x0400, 0x1da8: 0x0400, 0x1da9: 0x0400, + 0x1daa: 0x0400, 0x1dab: 0x0400, 0x1dac: 0x0400, 0x1dad: 0x0400, 0x1dae: 0x0400, 0x1daf: 0x0400, + 0x1db0: 0x0400, 0x1db1: 0x0400, 0x1db2: 0x0400, 0x1db3: 0x0400, 0x1db4: 0x0200, 0x1db5: 0x0400, + 0x1db6: 0x0400, 0x1db7: 0x0400, 0x1db8: 0x0400, 0x1db9: 0x0400, 0x1dba: 0x0400, 0x1dbb: 0x0400, + 0x1dbc: 0x0400, 0x1dbd: 0x0400, 0x1dbe: 0x0400, 0x1dbf: 0x0400, // Block 0x77, offset 0x1dc0 - 0x1dc0: 0x0080, 0x1dc1: 0x0080, 0x1dc2: 0x0080, 0x1dc3: 0x0080, 0x1dc4: 0x0080, 0x1dc5: 0x0080, - 0x1dc6: 0x0080, 0x1dc7: 0x0080, 0x1dc8: 0x0040, 0x1dc9: 0x0080, 0x1dca: 0x0080, 0x1dcb: 0x0080, - 0x1dcc: 0x0080, 0x1dcd: 0x0080, 0x1dce: 0x0080, 0x1dcf: 0x0080, 0x1dd0: 0x0080, 0x1dd1: 0x0080, - 0x1dd2: 0x0080, 0x1dd3: 0x0080, 0x1dd4: 0x0080, 0x1dd5: 0x0080, 0x1dd6: 0x0080, 0x1dd7: 0x0080, - 0x1dd8: 0x0080, 0x1dd9: 0x0080, 0x1dda: 0x0080, 0x1ddb: 0x0080, 0x1ddc: 0x0080, 0x1ddd: 0x0080, - 0x1dde: 0x0080, 0x1ddf: 0x0080, 0x1de0: 0x0080, 0x1de1: 0x0080, 0x1de2: 0x0080, 0x1de3: 0x0080, - 0x1de4: 0x0040, 0x1de5: 0x0080, 0x1de6: 0x0080, 0x1de7: 0x0080, 0x1de8: 0x0080, 0x1de9: 0x0080, - 0x1dea: 0x0080, 0x1deb: 0x0080, 0x1dec: 0x0080, 0x1ded: 0x0080, 0x1dee: 0x0080, 0x1def: 0x0080, - 0x1df0: 0x0080, 0x1df1: 0x0080, 0x1df2: 0x0080, 0x1df3: 0x0080, 0x1df4: 0x0080, 0x1df5: 0x0080, - 0x1df6: 0x0080, 0x1df7: 0x0080, 0x1df8: 0x0080, 0x1df9: 0x0080, 0x1dfa: 0x0080, 0x1dfb: 0x0080, - 0x1dfc: 0x0080, 0x1dfd: 0x0080, 0x1dfe: 0x0080, 0x1dff: 0x0080, + 0x1dc0: 0x0400, 0x1dc1: 0x0400, 0x1dc2: 0x0400, 0x1dc3: 0x0400, 0x1dc4: 0x0400, 0x1dc5: 0x0400, + 0x1dc6: 0x0400, 0x1dc7: 0x0400, 0x1dc8: 0x0400, 0x1dc9: 0x0400, 0x1dca: 0x0400, 0x1dcb: 0x0400, + 0x1dcc: 0x0400, 0x1dcd: 0x0400, 0x1dce: 0x0400, 0x1dcf: 0x0400, 0x1dd0: 0x0200, 0x1dd1: 0x0400, + 0x1dd2: 0x0400, 0x1dd3: 0x0400, 0x1dd4: 0x0400, 0x1dd5: 0x0400, 0x1dd6: 0x0400, 0x1dd7: 0x0400, + 0x1dd8: 0x0400, 0x1dd9: 0x0400, 0x1dda: 0x0400, 0x1ddb: 0x0400, 0x1ddc: 0x0400, 0x1ddd: 0x0400, + 0x1dde: 0x0400, 0x1ddf: 0x0400, 0x1de0: 0x0400, 0x1de1: 0x0400, 0x1de2: 0x0400, 0x1de3: 0x0400, + 0x1de4: 0x0400, 0x1de5: 0x0400, 0x1de6: 0x0400, 0x1de7: 0x0400, 0x1de8: 0x0400, 0x1de9: 0x0400, + 0x1dea: 0x0400, 0x1deb: 0x0400, 0x1dec: 0x0200, 0x1ded: 0x0400, 0x1dee: 0x0400, 0x1def: 0x0400, + 0x1df0: 0x0400, 0x1df1: 0x0400, 0x1df2: 0x0400, 0x1df3: 0x0400, 0x1df4: 0x0400, 0x1df5: 0x0400, + 0x1df6: 0x0400, 0x1df7: 0x0400, 0x1df8: 0x0400, 0x1df9: 0x0400, 0x1dfa: 0x0400, 0x1dfb: 0x0400, + 0x1dfc: 0x0400, 0x1dfd: 0x0400, 0x1dfe: 0x0400, 0x1dff: 0x0400, // Block 0x78, offset 0x1e00 - 0x1e00: 0x0080, 0x1e01: 0x0080, 0x1e02: 0x0080, 0x1e03: 0x0080, 0x1e04: 0x0080, 0x1e05: 0x0080, - 0x1e06: 0x0080, 0x1e07: 0x0080, 0x1e08: 0x0040, 0x1e09: 0x0080, 0x1e0a: 0x0080, 0x1e0b: 0x0080, - 0x1e0c: 0x0080, 0x1e0d: 0x0080, 0x1e0e: 0x0080, 0x1e0f: 0x0080, 0x1e10: 0x0080, 0x1e11: 0x0080, - 0x1e12: 0x0080, 0x1e13: 0x0080, 0x1e14: 0x0080, 0x1e15: 0x0080, 0x1e16: 0x0080, 0x1e17: 0x0080, - 0x1e18: 0x0080, 0x1e19: 0x0080, 0x1e1a: 0x0080, 0x1e1b: 0x0080, 0x1e1c: 0x0080, 0x1e1d: 0x0080, - 0x1e1e: 0x0080, 0x1e1f: 0x0080, 0x1e20: 0x0080, 0x1e21: 0x0080, 0x1e22: 0x0080, 0x1e23: 0x0080, - 0x1e30: 0x1000, 0x1e31: 0x1000, 0x1e32: 0x1000, 0x1e33: 0x1000, 0x1e34: 0x1000, 0x1e35: 0x1000, - 0x1e36: 0x1000, 0x1e37: 0x1000, 0x1e38: 0x1000, 0x1e39: 0x1000, 0x1e3a: 0x1000, 0x1e3b: 0x1000, - 0x1e3c: 0x1000, 0x1e3d: 0x1000, 0x1e3e: 0x1000, 0x1e3f: 0x1000, + 0x1e00: 0x0400, 0x1e01: 0x0400, 0x1e02: 0x0400, 0x1e03: 0x0400, 0x1e04: 0x0400, 0x1e05: 0x0400, + 0x1e06: 0x0400, 0x1e07: 0x0400, 0x1e08: 0x0200, 0x1e09: 0x0400, 0x1e0a: 0x0400, 0x1e0b: 0x0400, + 0x1e0c: 0x0400, 0x1e0d: 0x0400, 0x1e0e: 0x0400, 0x1e0f: 0x0400, 0x1e10: 0x0400, 0x1e11: 0x0400, + 0x1e12: 0x0400, 0x1e13: 0x0400, 0x1e14: 0x0400, 0x1e15: 0x0400, 0x1e16: 0x0400, 0x1e17: 0x0400, + 0x1e18: 0x0400, 0x1e19: 0x0400, 0x1e1a: 0x0400, 0x1e1b: 0x0400, 0x1e1c: 0x0400, 0x1e1d: 0x0400, + 0x1e1e: 0x0400, 0x1e1f: 0x0400, 0x1e20: 0x0400, 0x1e21: 0x0400, 0x1e22: 0x0400, 0x1e23: 0x0400, + 0x1e24: 0x0200, 0x1e25: 0x0400, 0x1e26: 0x0400, 0x1e27: 0x0400, 0x1e28: 0x0400, 0x1e29: 0x0400, + 0x1e2a: 0x0400, 0x1e2b: 0x0400, 0x1e2c: 0x0400, 0x1e2d: 0x0400, 0x1e2e: 0x0400, 0x1e2f: 0x0400, + 0x1e30: 0x0400, 0x1e31: 0x0400, 0x1e32: 0x0400, 0x1e33: 0x0400, 0x1e34: 0x0400, 0x1e35: 0x0400, + 0x1e36: 0x0400, 0x1e37: 0x0400, 0x1e38: 0x0400, 0x1e39: 0x0400, 0x1e3a: 0x0400, 0x1e3b: 0x0400, + 0x1e3c: 0x0400, 0x1e3d: 0x0400, 0x1e3e: 0x0400, 0x1e3f: 0x0400, // Block 0x79, offset 0x1e40 - 0x1e40: 0x1000, 0x1e41: 0x1000, 0x1e42: 0x1000, 0x1e43: 0x1000, 0x1e44: 0x1000, 0x1e45: 0x1000, - 0x1e46: 0x1000, 0x1e4b: 0x0800, - 0x1e4c: 0x0800, 0x1e4d: 0x0800, 0x1e4e: 0x0800, 0x1e4f: 0x0800, 0x1e50: 0x0800, 0x1e51: 0x0800, - 0x1e52: 0x0800, 0x1e53: 0x0800, 0x1e54: 0x0800, 0x1e55: 0x0800, 0x1e56: 0x0800, 0x1e57: 0x0800, - 0x1e58: 0x0800, 0x1e59: 0x0800, 0x1e5a: 0x0800, 0x1e5b: 0x0800, 0x1e5c: 0x0800, 0x1e5d: 0x0800, - 0x1e5e: 0x0800, 0x1e5f: 0x0800, 0x1e60: 0x0800, 0x1e61: 0x0800, 0x1e62: 0x0800, 0x1e63: 0x0800, - 0x1e64: 0x0800, 0x1e65: 0x0800, 0x1e66: 0x0800, 0x1e67: 0x0800, 0x1e68: 0x0800, 0x1e69: 0x0800, - 0x1e6a: 0x0800, 0x1e6b: 0x0800, 0x1e6c: 0x0800, 0x1e6d: 0x0800, 0x1e6e: 0x0800, 0x1e6f: 0x0800, - 0x1e70: 0x0800, 0x1e71: 0x0800, 0x1e72: 0x0800, 0x1e73: 0x0800, 0x1e74: 0x0800, 0x1e75: 0x0800, - 0x1e76: 0x0800, 0x1e77: 0x0800, 0x1e78: 0x0800, 0x1e79: 0x0800, 0x1e7a: 0x0800, 0x1e7b: 0x0800, + 0x1e40: 0x0400, 0x1e41: 0x0400, 0x1e42: 0x0400, 0x1e43: 0x0400, 0x1e44: 0x0400, 0x1e45: 0x0400, + 0x1e46: 0x0400, 0x1e47: 0x0400, 0x1e48: 0x0200, 0x1e49: 0x0400, 0x1e4a: 0x0400, 0x1e4b: 0x0400, + 0x1e4c: 0x0400, 0x1e4d: 0x0400, 0x1e4e: 0x0400, 0x1e4f: 0x0400, 0x1e50: 0x0400, 0x1e51: 0x0400, + 0x1e52: 0x0400, 0x1e53: 0x0400, 0x1e54: 0x0400, 0x1e55: 0x0400, 0x1e56: 0x0400, 0x1e57: 0x0400, + 0x1e58: 0x0400, 0x1e59: 0x0400, 0x1e5a: 0x0400, 0x1e5b: 0x0400, 0x1e5c: 0x0400, 0x1e5d: 0x0400, + 0x1e5e: 0x0400, 0x1e5f: 0x0400, 0x1e60: 0x0400, 0x1e61: 0x0400, 0x1e62: 0x0400, 0x1e63: 0x0400, + 0x1e70: 0x8000, 0x1e71: 0x8000, 0x1e72: 0x8000, 0x1e73: 0x8000, 0x1e74: 0x8000, 0x1e75: 0x8000, + 0x1e76: 0x8000, 0x1e77: 0x8000, 0x1e78: 0x8000, 0x1e79: 0x8000, 0x1e7a: 0x8000, 0x1e7b: 0x8000, + 0x1e7c: 0x8000, 0x1e7d: 0x8000, 0x1e7e: 0x8000, 0x1e7f: 0x8000, // Block 0x7a, offset 0x1e80 - 0x1e9e: 0x0004, + 0x1e80: 0x8000, 0x1e81: 0x8000, 0x1e82: 0x8000, 0x1e83: 0x8000, 0x1e84: 0x8000, 0x1e85: 0x8000, + 0x1e86: 0x8000, 0x1e8b: 0x4000, + 0x1e8c: 0x4000, 0x1e8d: 0x4000, 0x1e8e: 0x4000, 0x1e8f: 0x4000, 0x1e90: 0x4000, 0x1e91: 0x4000, + 0x1e92: 0x4000, 0x1e93: 0x4000, 0x1e94: 0x4000, 0x1e95: 0x4000, 0x1e96: 0x4000, 0x1e97: 0x4000, + 0x1e98: 0x4000, 0x1e99: 0x4000, 0x1e9a: 0x4000, 0x1e9b: 0x4000, 0x1e9c: 0x4000, 0x1e9d: 0x4000, + 0x1e9e: 0x4000, 0x1e9f: 0x4000, 0x1ea0: 0x4000, 0x1ea1: 0x4000, 0x1ea2: 0x4000, 0x1ea3: 0x4000, + 0x1ea4: 0x4000, 0x1ea5: 0x4000, 0x1ea6: 0x4000, 0x1ea7: 0x4000, 0x1ea8: 0x4000, 0x1ea9: 0x4000, + 0x1eaa: 0x4000, 0x1eab: 0x4000, 0x1eac: 0x4000, 0x1ead: 0x4000, 0x1eae: 0x4000, 0x1eaf: 0x4000, + 0x1eb0: 0x4000, 0x1eb1: 0x4000, 0x1eb2: 0x4000, 0x1eb3: 0x4000, 0x1eb4: 0x4000, 0x1eb5: 0x4000, + 0x1eb6: 0x4000, 0x1eb7: 0x4000, 0x1eb8: 0x4000, 0x1eb9: 0x4000, 0x1eba: 0x4000, 0x1ebb: 0x4000, // Block 0x7b, offset 0x1ec0 - 0x1ec0: 0x0004, 0x1ec1: 0x0004, 0x1ec2: 0x0004, 0x1ec3: 0x0004, 0x1ec4: 0x0004, 0x1ec5: 0x0004, - 0x1ec6: 0x0004, 0x1ec7: 0x0004, 0x1ec8: 0x0004, 0x1ec9: 0x0004, 0x1eca: 0x0004, 0x1ecb: 0x0004, - 0x1ecc: 0x0004, 0x1ecd: 0x0004, 0x1ece: 0x0004, 0x1ecf: 0x0004, - 0x1ee0: 0x0004, 0x1ee1: 0x0004, 0x1ee2: 0x0004, 0x1ee3: 0x0004, - 0x1ee4: 0x0004, 0x1ee5: 0x0004, 0x1ee6: 0x0004, 0x1ee7: 0x0004, 0x1ee8: 0x0004, 0x1ee9: 0x0004, - 0x1eea: 0x0004, 0x1eeb: 0x0004, 0x1eec: 0x0004, 0x1eed: 0x0004, 0x1eee: 0x0004, 0x1eef: 0x0004, + 0x1ede: 0x0024, // Block 0x7c, offset 0x1f00 - 0x1f3f: 0x0002, + 0x1f00: 0x0024, 0x1f01: 0x0024, 0x1f02: 0x0024, 0x1f03: 0x0024, 0x1f04: 0x0024, 0x1f05: 0x0024, + 0x1f06: 0x0024, 0x1f07: 0x0024, 0x1f08: 0x0024, 0x1f09: 0x0024, 0x1f0a: 0x0024, 0x1f0b: 0x0024, + 0x1f0c: 0x0024, 0x1f0d: 0x0024, 0x1f0e: 0x0024, 0x1f0f: 0x0024, + 0x1f20: 0x0024, 0x1f21: 0x0024, 0x1f22: 0x0024, 0x1f23: 0x0024, + 0x1f24: 0x0024, 0x1f25: 0x0024, 0x1f26: 0x0024, 0x1f27: 0x0024, 0x1f28: 0x0024, 0x1f29: 0x0024, + 0x1f2a: 0x0024, 0x1f2b: 0x0024, 0x1f2c: 0x0024, 0x1f2d: 0x0024, 0x1f2e: 0x0024, 0x1f2f: 0x0024, // Block 0x7d, offset 0x1f40 - 0x1f70: 0x0002, 0x1f71: 0x0002, 0x1f72: 0x0002, 0x1f73: 0x0002, 0x1f74: 0x0002, 0x1f75: 0x0002, - 0x1f76: 0x0002, 0x1f77: 0x0002, 0x1f78: 0x0002, 0x1f79: 0x0002, 0x1f7a: 0x0002, 0x1f7b: 0x0002, + 0x1f7f: 0x0002, // Block 0x7e, offset 0x1f80 - 0x1fbd: 0x0004, + 0x1fb0: 0x0002, 0x1fb1: 0x0002, 0x1fb2: 0x0002, 0x1fb3: 0x0002, 0x1fb4: 0x0002, 0x1fb5: 0x0002, + 0x1fb6: 0x0002, 0x1fb7: 0x0002, 0x1fb8: 0x0002, 0x1fb9: 0x0002, 0x1fba: 0x0002, 0x1fbb: 0x0002, // Block 0x7f, offset 0x1fc0 - 0x1fe0: 0x0004, + 0x1ffd: 0x0024, // Block 0x80, offset 0x2000 - 0x2036: 0x0004, 0x2037: 0x0004, 0x2038: 0x0004, 0x2039: 0x0004, 0x203a: 0x0004, + 0x2020: 0x0024, // Block 0x81, offset 0x2040 - 0x2041: 0x0004, 0x2042: 0x0004, 0x2043: 0x0004, 0x2045: 0x0004, - 0x2046: 0x0004, - 0x204c: 0x0004, 0x204d: 0x0004, 0x204e: 0x0004, 0x204f: 0x0004, - 0x2078: 0x0004, 0x2079: 0x0004, 0x207a: 0x0004, - 0x207f: 0x0004, + 0x2076: 0x0024, 0x2077: 0x0024, 0x2078: 0x0024, 0x2079: 0x0024, 0x207a: 0x0024, // Block 0x82, offset 0x2080 - 0x20a5: 0x0004, 0x20a6: 0x0004, + 0x2080: 0x0010, 0x2081: 0x0024, 0x2082: 0x0024, 0x2083: 0x0024, 0x2085: 0x0024, + 0x2086: 0x0024, + 0x208c: 0x0024, 0x208d: 0x0024, 0x208e: 0x0024, 0x208f: 0x0024, 0x2090: 0x0010, 0x2091: 0x0010, + 0x2092: 0x0010, 0x2093: 0x0010, 0x2095: 0x0010, 0x2096: 0x0010, 0x2097: 0x0010, + 0x2099: 0x0010, 0x209a: 0x0010, 0x209b: 0x0010, 0x209c: 0x0010, 0x209d: 0x0010, + 0x209e: 0x0010, 0x209f: 0x0010, 0x20a0: 0x0010, 0x20a1: 0x0010, 0x20a2: 0x0010, 0x20a3: 0x0010, + 0x20a4: 0x0010, 0x20a5: 0x0010, 0x20a6: 0x0010, 0x20a7: 0x0010, 0x20a8: 0x0010, 0x20a9: 0x0010, + 0x20aa: 0x0010, 0x20ab: 0x0010, 0x20ac: 0x0010, 0x20ad: 0x0010, 0x20ae: 0x0010, 0x20af: 0x0010, + 0x20b0: 0x0010, 0x20b1: 0x0010, 0x20b2: 0x0010, 0x20b3: 0x0010, 0x20b4: 0x0010, 0x20b5: 0x0010, + 0x20b8: 0x0024, 0x20b9: 0x0024, 0x20ba: 0x0024, + 0x20bf: 0x0044, // Block 0x83, offset 0x20c0 - 0x20e4: 0x0004, 0x20e5: 0x0004, 0x20e6: 0x0004, 0x20e7: 0x0004, + 0x20e5: 0x0024, 0x20e6: 0x0024, // Block 0x84, offset 0x2100 - 0x212b: 0x0004, 0x212c: 0x0004, + 0x2124: 0x0024, 0x2125: 0x0024, 0x2126: 0x0024, 0x2127: 0x0024, // Block 0x85, offset 0x2140 - 0x217d: 0x0004, 0x217e: 0x0004, 0x217f: 0x0004, + 0x2169: 0x0024, + 0x216a: 0x0024, 0x216b: 0x0024, 0x216c: 0x0024, 0x216d: 0x0024, // Block 0x86, offset 0x2180 - 0x2186: 0x0004, 0x2187: 0x0004, 0x2188: 0x0004, 0x2189: 0x0004, 0x218a: 0x0004, 0x218b: 0x0004, - 0x218c: 0x0004, 0x218d: 0x0004, 0x218e: 0x0004, 0x218f: 0x0004, 0x2190: 0x0004, + 0x21ab: 0x0024, 0x21ac: 0x0024, // Block 0x87, offset 0x21c0 - 0x21c2: 0x0004, 0x21c3: 0x0004, 0x21c4: 0x0004, 0x21c5: 0x0004, + 0x21fa: 0x0024, 0x21fb: 0x0024, + 0x21fc: 0x0024, 0x21fd: 0x0024, 0x21fe: 0x0024, 0x21ff: 0x0024, // Block 0x88, offset 0x2200 - 0x2200: 0x0400, 0x2201: 0x0004, 0x2202: 0x0400, - 0x2238: 0x0004, 0x2239: 0x0004, 0x223a: 0x0004, 0x223b: 0x0004, - 0x223c: 0x0004, 0x223d: 0x0004, 0x223e: 0x0004, 0x223f: 0x0004, + 0x2206: 0x0024, 0x2207: 0x0024, 0x2208: 0x0024, 0x2209: 0x0024, 0x220a: 0x0024, 0x220b: 0x0024, + 0x220c: 0x0024, 0x220d: 0x0024, 0x220e: 0x0024, 0x220f: 0x0024, 0x2210: 0x0024, // Block 0x89, offset 0x2240 - 0x2240: 0x0004, 0x2241: 0x0004, 0x2242: 0x0004, 0x2243: 0x0004, 0x2244: 0x0004, 0x2245: 0x0004, - 0x2246: 0x0004, - 0x2270: 0x0004, 0x2273: 0x0004, 0x2274: 0x0004, - 0x227f: 0x0004, + 0x2242: 0x0024, 0x2243: 0x0024, 0x2244: 0x0024, 0x2245: 0x0024, // Block 0x8a, offset 0x2280 - 0x2280: 0x0004, 0x2281: 0x0004, 0x2282: 0x0400, - 0x22b0: 0x0400, 0x22b1: 0x0400, 0x22b2: 0x0400, 0x22b3: 0x0004, 0x22b4: 0x0004, 0x22b5: 0x0004, - 0x22b6: 0x0004, 0x22b7: 0x0400, 0x22b8: 0x0400, 0x22b9: 0x0004, 0x22ba: 0x0004, - 0x22bd: 0x0100, + 0x2280: 0x2000, 0x2281: 0x0024, 0x2282: 0x2000, + 0x22b8: 0x0024, 0x22b9: 0x0024, 0x22ba: 0x0024, 0x22bb: 0x0024, + 0x22bc: 0x0024, 0x22bd: 0x0024, 0x22be: 0x0024, 0x22bf: 0x0024, // Block 0x8b, offset 0x22c0 - 0x22c2: 0x0004, - 0x22cd: 0x0100, + 0x22c0: 0x0024, 0x22c1: 0x0024, 0x22c2: 0x0024, 0x22c3: 0x0024, 0x22c4: 0x0024, 0x22c5: 0x0024, + 0x22c6: 0x0024, + 0x22f0: 0x0024, 0x22f3: 0x0024, 0x22f4: 0x0024, + 0x22ff: 0x0024, // Block 0x8c, offset 0x2300 - 0x2300: 0x0004, 0x2301: 0x0004, 0x2302: 0x0004, - 0x2327: 0x0004, 0x2328: 0x0004, 0x2329: 0x0004, - 0x232a: 0x0004, 0x232b: 0x0004, 0x232c: 0x0400, 0x232d: 0x0004, 0x232e: 0x0004, 0x232f: 0x0004, - 0x2330: 0x0004, 0x2331: 0x0004, 0x2332: 0x0004, 0x2333: 0x0004, 0x2334: 0x0004, + 0x2300: 0x0024, 0x2301: 0x0024, 0x2302: 0x2000, + 0x2330: 0x2000, 0x2331: 0x2000, 0x2332: 0x2000, 0x2333: 0x0024, 0x2334: 0x0024, 0x2335: 0x0024, + 0x2336: 0x0024, 0x2337: 0x2000, 0x2338: 0x2000, 0x2339: 0x0024, 0x233a: 0x0024, + 0x233d: 0x0800, // Block 0x8d, offset 0x2340 - 0x2345: 0x0400, - 0x2346: 0x0400, - 0x2373: 0x0004, + 0x2342: 0x0024, + 0x234d: 0x0800, // Block 0x8e, offset 0x2380 - 0x2380: 0x0004, 0x2381: 0x0004, 0x2382: 0x0400, - 0x23b3: 0x0400, 0x23b4: 0x0400, 0x23b5: 0x0400, - 0x23b6: 0x0004, 0x23b7: 0x0004, 0x23b8: 0x0004, 0x23b9: 0x0004, 0x23ba: 0x0004, 0x23bb: 0x0004, - 0x23bc: 0x0004, 0x23bd: 0x0004, 0x23be: 0x0004, 0x23bf: 0x0400, + 0x2380: 0x0024, 0x2381: 0x0024, 0x2382: 0x0024, 0x2383: 0x0010, 0x2384: 0x0010, 0x2385: 0x0010, + 0x2386: 0x0010, 0x2387: 0x0010, 0x2388: 0x0010, 0x2389: 0x0010, 0x238a: 0x0010, 0x238b: 0x0010, + 0x238c: 0x0010, 0x238d: 0x0010, 0x238e: 0x0010, 0x238f: 0x0010, 0x2390: 0x0010, 0x2391: 0x0010, + 0x2392: 0x0010, 0x2393: 0x0010, 0x2394: 0x0010, 0x2395: 0x0010, 0x2396: 0x0010, 0x2397: 0x0010, + 0x2398: 0x0010, 0x2399: 0x0010, 0x239a: 0x0010, 0x239b: 0x0010, 0x239c: 0x0010, 0x239d: 0x0010, + 0x239e: 0x0010, 0x239f: 0x0010, 0x23a0: 0x0010, 0x23a1: 0x0010, 0x23a2: 0x0010, 0x23a3: 0x0010, + 0x23a4: 0x0010, 0x23a5: 0x0010, 0x23a6: 0x0010, 0x23a7: 0x0024, 0x23a8: 0x0024, 0x23a9: 0x0024, + 0x23aa: 0x0024, 0x23ab: 0x0024, 0x23ac: 0x2000, 0x23ad: 0x0024, 0x23ae: 0x0024, 0x23af: 0x0024, + 0x23b0: 0x0024, 0x23b1: 0x0024, 0x23b2: 0x0024, 0x23b3: 0x0044, 0x23b4: 0x0024, // Block 0x8f, offset 0x23c0 - 0x23c0: 0x0400, 0x23c2: 0x0100, 0x23c3: 0x0100, - 0x23c9: 0x0004, 0x23ca: 0x0004, 0x23cb: 0x0004, - 0x23cc: 0x0004, 0x23ce: 0x0400, 0x23cf: 0x0004, + 0x23c4: 0x0010, 0x23c5: 0x2000, + 0x23c6: 0x2000, 0x23c7: 0x0010, + 0x23f3: 0x0024, // Block 0x90, offset 0x2400 - 0x242c: 0x0400, 0x242d: 0x0400, 0x242e: 0x0400, 0x242f: 0x0004, - 0x2430: 0x0004, 0x2431: 0x0004, 0x2432: 0x0400, 0x2433: 0x0400, 0x2434: 0x0004, 0x2435: 0x0400, - 0x2436: 0x0004, 0x2437: 0x0004, - 0x243e: 0x0004, + 0x2400: 0x0024, 0x2401: 0x0024, 0x2402: 0x2000, + 0x2433: 0x2000, 0x2434: 0x2000, 0x2435: 0x2000, + 0x2436: 0x0024, 0x2437: 0x0024, 0x2438: 0x0024, 0x2439: 0x0024, 0x243a: 0x0024, 0x243b: 0x0024, + 0x243c: 0x0024, 0x243d: 0x0024, 0x243e: 0x0024, 0x243f: 0x2000, // Block 0x91, offset 0x2440 - 0x2441: 0x0004, + 0x2440: 0x0024, 0x2442: 0x0800, 0x2443: 0x0800, + 0x2449: 0x0024, 0x244a: 0x0024, 0x244b: 0x0024, + 0x244c: 0x0024, 0x244e: 0x2000, 0x244f: 0x0024, // Block 0x92, offset 0x2480 - 0x249f: 0x0004, 0x24a0: 0x0400, 0x24a1: 0x0400, 0x24a2: 0x0400, 0x24a3: 0x0004, - 0x24a4: 0x0004, 0x24a5: 0x0004, 0x24a6: 0x0004, 0x24a7: 0x0004, 0x24a8: 0x0004, 0x24a9: 0x0004, - 0x24aa: 0x0004, + 0x24ac: 0x2000, 0x24ad: 0x2000, 0x24ae: 0x2000, 0x24af: 0x0024, + 0x24b0: 0x0024, 0x24b1: 0x0024, 0x24b2: 0x2000, 0x24b3: 0x2000, 0x24b4: 0x0024, 0x24b5: 0x0024, + 0x24b6: 0x0024, 0x24b7: 0x0024, + 0x24be: 0x0024, // Block 0x93, offset 0x24c0 - 0x24c0: 0x0004, 0x24c1: 0x0400, 0x24c2: 0x0400, 0x24c3: 0x0400, 0x24c4: 0x0400, - 0x24c7: 0x0400, 0x24c8: 0x0400, 0x24cb: 0x0400, - 0x24cc: 0x0400, 0x24cd: 0x0400, - 0x24d7: 0x0004, - 0x24e2: 0x0400, 0x24e3: 0x0400, - 0x24e6: 0x0004, 0x24e7: 0x0004, 0x24e8: 0x0004, 0x24e9: 0x0004, - 0x24ea: 0x0004, 0x24eb: 0x0004, 0x24ec: 0x0004, - 0x24f0: 0x0004, 0x24f1: 0x0004, 0x24f2: 0x0004, 0x24f3: 0x0004, 0x24f4: 0x0004, + 0x24c1: 0x0024, // Block 0x94, offset 0x2500 - 0x2535: 0x0400, - 0x2536: 0x0400, 0x2537: 0x0400, 0x2538: 0x0004, 0x2539: 0x0004, 0x253a: 0x0004, 0x253b: 0x0004, - 0x253c: 0x0004, 0x253d: 0x0004, 0x253e: 0x0004, 0x253f: 0x0004, + 0x251f: 0x0024, 0x2520: 0x2000, 0x2521: 0x2000, 0x2522: 0x2000, 0x2523: 0x0024, + 0x2524: 0x0024, 0x2525: 0x0024, 0x2526: 0x0024, 0x2527: 0x0024, 0x2528: 0x0024, 0x2529: 0x0024, + 0x252a: 0x0024, // Block 0x95, offset 0x2540 - 0x2540: 0x0400, 0x2541: 0x0400, 0x2542: 0x0004, 0x2543: 0x0004, 0x2544: 0x0004, 0x2545: 0x0400, - 0x2546: 0x0004, - 0x255e: 0x0004, + 0x2540: 0x0024, 0x2541: 0x0024, 0x2542: 0x2000, 0x2543: 0x2000, + 0x257b: 0x0024, + 0x257c: 0x0024, 0x257e: 0x0024, 0x257f: 0x2000, // Block 0x96, offset 0x2580 - 0x25b0: 0x0004, 0x25b1: 0x0400, 0x25b2: 0x0400, 0x25b3: 0x0004, 0x25b4: 0x0004, 0x25b5: 0x0004, - 0x25b6: 0x0004, 0x25b7: 0x0004, 0x25b8: 0x0004, 0x25b9: 0x0400, 0x25ba: 0x0004, 0x25bb: 0x0400, - 0x25bc: 0x0400, 0x25bd: 0x0004, 0x25be: 0x0400, 0x25bf: 0x0004, + 0x2580: 0x0024, 0x2581: 0x2000, 0x2582: 0x2000, 0x2583: 0x2000, 0x2584: 0x2000, + 0x2587: 0x2000, 0x2588: 0x2000, 0x258b: 0x2000, + 0x258c: 0x2000, 0x258d: 0x0024, + 0x2597: 0x0024, + 0x25a2: 0x2000, 0x25a3: 0x2000, + 0x25a6: 0x0024, 0x25a7: 0x0024, 0x25a8: 0x0024, 0x25a9: 0x0024, + 0x25aa: 0x0024, 0x25ab: 0x0024, 0x25ac: 0x0024, + 0x25b0: 0x0024, 0x25b1: 0x0024, 0x25b2: 0x0024, 0x25b3: 0x0024, 0x25b4: 0x0024, // Block 0x97, offset 0x25c0 - 0x25c0: 0x0004, 0x25c1: 0x0400, 0x25c2: 0x0004, 0x25c3: 0x0004, + 0x25c0: 0x0010, 0x25c1: 0x0010, 0x25c2: 0x0010, 0x25c3: 0x0010, 0x25c4: 0x0010, 0x25c5: 0x0010, + 0x25c6: 0x0010, 0x25c7: 0x0010, 0x25c8: 0x0010, 0x25c9: 0x0010, 0x25cb: 0x0010, + 0x25ce: 0x0010, 0x25d0: 0x0010, 0x25d1: 0x0010, + 0x25d2: 0x0010, 0x25d3: 0x0010, 0x25d4: 0x0010, 0x25d5: 0x0010, 0x25d6: 0x0010, 0x25d7: 0x0010, + 0x25d8: 0x0010, 0x25d9: 0x0010, 0x25da: 0x0010, 0x25db: 0x0010, 0x25dc: 0x0010, 0x25dd: 0x0010, + 0x25de: 0x0010, 0x25df: 0x0010, 0x25e0: 0x0010, 0x25e1: 0x0010, 0x25e2: 0x0010, 0x25e3: 0x0010, + 0x25e4: 0x0010, 0x25e5: 0x0010, 0x25e6: 0x0010, 0x25e7: 0x0010, 0x25e8: 0x0010, 0x25e9: 0x0010, + 0x25ea: 0x0010, 0x25eb: 0x0010, 0x25ec: 0x0010, 0x25ed: 0x0010, 0x25ee: 0x0010, 0x25ef: 0x0010, + 0x25f0: 0x0010, 0x25f1: 0x0010, 0x25f2: 0x0010, 0x25f3: 0x0010, 0x25f4: 0x0010, 0x25f5: 0x0010, + 0x25f8: 0x0024, 0x25f9: 0x2000, 0x25fa: 0x2000, 0x25fb: 0x0024, + 0x25fc: 0x0024, 0x25fd: 0x0024, 0x25fe: 0x0024, 0x25ff: 0x0024, // Block 0x98, offset 0x2600 - 0x262f: 0x0004, - 0x2630: 0x0400, 0x2631: 0x0400, 0x2632: 0x0004, 0x2633: 0x0004, 0x2634: 0x0004, 0x2635: 0x0004, - 0x2638: 0x0400, 0x2639: 0x0400, 0x263a: 0x0400, 0x263b: 0x0400, - 0x263c: 0x0004, 0x263d: 0x0004, 0x263e: 0x0400, 0x263f: 0x0004, + 0x2600: 0x0024, 0x2602: 0x0024, 0x2605: 0x0024, + 0x2607: 0x0024, 0x2608: 0x0024, 0x2609: 0x0024, 0x260a: 0x2000, + 0x260c: 0x2000, 0x260d: 0x2000, 0x260e: 0x0024, 0x260f: 0x0024, 0x2610: 0x0044, 0x2611: 0x0800, + 0x2612: 0x0024, + 0x2621: 0x0024, 0x2622: 0x0024, // Block 0x99, offset 0x2640 - 0x2640: 0x0004, - 0x265c: 0x0004, 0x265d: 0x0004, + 0x2675: 0x2000, + 0x2676: 0x2000, 0x2677: 0x2000, 0x2678: 0x0024, 0x2679: 0x0024, 0x267a: 0x0024, 0x267b: 0x0024, + 0x267c: 0x0024, 0x267d: 0x0024, 0x267e: 0x0024, 0x267f: 0x0024, // Block 0x9a, offset 0x2680 - 0x26b0: 0x0400, 0x26b1: 0x0400, 0x26b2: 0x0400, 0x26b3: 0x0004, 0x26b4: 0x0004, 0x26b5: 0x0004, - 0x26b6: 0x0004, 0x26b7: 0x0004, 0x26b8: 0x0004, 0x26b9: 0x0004, 0x26ba: 0x0004, 0x26bb: 0x0400, - 0x26bc: 0x0400, 0x26bd: 0x0004, 0x26be: 0x0400, 0x26bf: 0x0004, + 0x2680: 0x2000, 0x2681: 0x2000, 0x2682: 0x0024, 0x2683: 0x0024, 0x2684: 0x0024, 0x2685: 0x2000, + 0x2686: 0x0024, + 0x269e: 0x0024, // Block 0x9b, offset 0x26c0 - 0x26c0: 0x0004, + 0x26f0: 0x0024, 0x26f1: 0x2000, 0x26f2: 0x2000, 0x26f3: 0x0024, 0x26f4: 0x0024, 0x26f5: 0x0024, + 0x26f6: 0x0024, 0x26f7: 0x0024, 0x26f8: 0x0024, 0x26f9: 0x2000, 0x26fa: 0x0024, 0x26fb: 0x2000, + 0x26fc: 0x2000, 0x26fd: 0x0024, 0x26fe: 0x2000, 0x26ff: 0x0024, // Block 0x9c, offset 0x2700 - 0x272b: 0x0004, 0x272c: 0x0400, 0x272d: 0x0004, 0x272e: 0x0400, 0x272f: 0x0400, - 0x2730: 0x0004, 0x2731: 0x0004, 0x2732: 0x0004, 0x2733: 0x0004, 0x2734: 0x0004, 0x2735: 0x0004, - 0x2736: 0x0400, 0x2737: 0x0004, + 0x2700: 0x0024, 0x2701: 0x2000, 0x2702: 0x0024, 0x2703: 0x0024, // Block 0x9d, offset 0x2740 - 0x275d: 0x0004, - 0x275e: 0x0004, 0x275f: 0x0004, 0x2762: 0x0004, 0x2763: 0x0004, - 0x2764: 0x0004, 0x2765: 0x0004, 0x2766: 0x0400, 0x2767: 0x0004, 0x2768: 0x0004, 0x2769: 0x0004, - 0x276a: 0x0004, 0x276b: 0x0004, + 0x276f: 0x0024, + 0x2770: 0x2000, 0x2771: 0x2000, 0x2772: 0x0024, 0x2773: 0x0024, 0x2774: 0x0024, 0x2775: 0x0024, + 0x2778: 0x2000, 0x2779: 0x2000, 0x277a: 0x2000, 0x277b: 0x2000, + 0x277c: 0x0024, 0x277d: 0x0024, 0x277e: 0x2000, 0x277f: 0x0024, // Block 0x9e, offset 0x2780 - 0x27ac: 0x0400, 0x27ad: 0x0400, 0x27ae: 0x0400, 0x27af: 0x0004, - 0x27b0: 0x0004, 0x27b1: 0x0004, 0x27b2: 0x0004, 0x27b3: 0x0004, 0x27b4: 0x0004, 0x27b5: 0x0004, - 0x27b6: 0x0004, 0x27b7: 0x0004, 0x27b8: 0x0400, 0x27b9: 0x0004, 0x27ba: 0x0004, + 0x2780: 0x0024, + 0x279c: 0x0024, 0x279d: 0x0024, // Block 0x9f, offset 0x27c0 - 0x27f0: 0x0004, 0x27f1: 0x0400, 0x27f2: 0x0400, 0x27f3: 0x0400, 0x27f4: 0x0400, 0x27f5: 0x0400, - 0x27f7: 0x0400, 0x27f8: 0x0400, 0x27fb: 0x0004, - 0x27fc: 0x0004, 0x27fd: 0x0400, 0x27fe: 0x0004, 0x27ff: 0x0100, + 0x27f0: 0x2000, 0x27f1: 0x2000, 0x27f2: 0x2000, 0x27f3: 0x0024, 0x27f4: 0x0024, 0x27f5: 0x0024, + 0x27f6: 0x0024, 0x27f7: 0x0024, 0x27f8: 0x0024, 0x27f9: 0x0024, 0x27fa: 0x0024, 0x27fb: 0x2000, + 0x27fc: 0x2000, 0x27fd: 0x0024, 0x27fe: 0x2000, 0x27ff: 0x0024, // Block 0xa0, offset 0x2800 - 0x2800: 0x0400, 0x2801: 0x0100, 0x2802: 0x0400, 0x2803: 0x0004, + 0x2800: 0x0024, // Block 0xa1, offset 0x2840 - 0x2851: 0x0400, - 0x2852: 0x0400, 0x2853: 0x0400, 0x2854: 0x0004, 0x2855: 0x0004, 0x2856: 0x0004, 0x2857: 0x0004, - 0x285a: 0x0004, 0x285b: 0x0004, 0x285c: 0x0400, 0x285d: 0x0400, - 0x285e: 0x0400, 0x285f: 0x0400, 0x2860: 0x0004, - 0x2864: 0x0400, + 0x286b: 0x0024, 0x286c: 0x2000, 0x286d: 0x0024, 0x286e: 0x2000, 0x286f: 0x2000, + 0x2870: 0x0024, 0x2871: 0x0024, 0x2872: 0x0024, 0x2873: 0x0024, 0x2874: 0x0024, 0x2875: 0x0024, + 0x2876: 0x0024, 0x2877: 0x0024, // Block 0xa2, offset 0x2880 - 0x2881: 0x0004, 0x2882: 0x0004, 0x2883: 0x0004, 0x2884: 0x0004, 0x2885: 0x0004, - 0x2886: 0x0004, 0x2887: 0x0004, 0x2888: 0x0004, 0x2889: 0x0004, 0x288a: 0x0004, - 0x28b3: 0x0004, 0x28b4: 0x0004, 0x28b5: 0x0004, - 0x28b6: 0x0004, 0x28b7: 0x0004, 0x28b8: 0x0004, 0x28b9: 0x0400, 0x28ba: 0x0100, 0x28bb: 0x0004, - 0x28bc: 0x0004, 0x28bd: 0x0004, 0x28be: 0x0004, + 0x289d: 0x0024, + 0x289e: 0x2000, 0x289f: 0x0024, 0x28a2: 0x0024, 0x28a3: 0x0024, + 0x28a4: 0x0024, 0x28a5: 0x0024, 0x28a6: 0x2000, 0x28a7: 0x0024, 0x28a8: 0x0024, 0x28a9: 0x0024, + 0x28aa: 0x0024, 0x28ab: 0x0024, // Block 0xa3, offset 0x28c0 - 0x28c7: 0x0004, - 0x28d1: 0x0004, - 0x28d2: 0x0004, 0x28d3: 0x0004, 0x28d4: 0x0004, 0x28d5: 0x0004, 0x28d6: 0x0004, 0x28d7: 0x0400, - 0x28d8: 0x0400, 0x28d9: 0x0004, 0x28da: 0x0004, 0x28db: 0x0004, + 0x28ec: 0x2000, 0x28ed: 0x2000, 0x28ee: 0x2000, 0x28ef: 0x0024, + 0x28f0: 0x0024, 0x28f1: 0x0024, 0x28f2: 0x0024, 0x28f3: 0x0024, 0x28f4: 0x0024, 0x28f5: 0x0024, + 0x28f6: 0x0024, 0x28f7: 0x0024, 0x28f8: 0x2000, 0x28f9: 0x0024, 0x28fa: 0x0024, // Block 0xa4, offset 0x2900 - 0x2904: 0x0100, 0x2905: 0x0100, - 0x2906: 0x0100, 0x2907: 0x0100, 0x2908: 0x0100, 0x2909: 0x0100, 0x290a: 0x0004, 0x290b: 0x0004, - 0x290c: 0x0004, 0x290d: 0x0004, 0x290e: 0x0004, 0x290f: 0x0004, 0x2910: 0x0004, 0x2911: 0x0004, - 0x2912: 0x0004, 0x2913: 0x0004, 0x2914: 0x0004, 0x2915: 0x0004, 0x2916: 0x0004, 0x2917: 0x0400, - 0x2918: 0x0004, 0x2919: 0x0004, + 0x2900: 0x0010, 0x2901: 0x0010, 0x2902: 0x0010, 0x2903: 0x0010, 0x2904: 0x0010, 0x2905: 0x0010, + 0x2906: 0x0010, 0x2909: 0x0010, + 0x290c: 0x0010, 0x290d: 0x0010, 0x290e: 0x0010, 0x290f: 0x0010, 0x2910: 0x0010, 0x2911: 0x0010, + 0x2912: 0x0010, 0x2913: 0x0010, 0x2915: 0x0010, 0x2916: 0x0010, + 0x2918: 0x0010, 0x2919: 0x0010, 0x291a: 0x0010, 0x291b: 0x0010, 0x291c: 0x0010, 0x291d: 0x0010, + 0x291e: 0x0010, 0x291f: 0x0010, 0x2920: 0x0010, 0x2921: 0x0010, 0x2922: 0x0010, 0x2923: 0x0010, + 0x2924: 0x0010, 0x2925: 0x0010, 0x2926: 0x0010, 0x2927: 0x0010, 0x2928: 0x0010, 0x2929: 0x0010, + 0x292a: 0x0010, 0x292b: 0x0010, 0x292c: 0x0010, 0x292d: 0x0010, 0x292e: 0x0010, 0x292f: 0x0010, + 0x2930: 0x0024, 0x2931: 0x2000, 0x2932: 0x2000, 0x2933: 0x2000, 0x2934: 0x2000, 0x2935: 0x2000, + 0x2937: 0x2000, 0x2938: 0x2000, 0x293b: 0x0024, + 0x293c: 0x0024, 0x293d: 0x0024, 0x293e: 0x0044, 0x293f: 0x0800, // Block 0xa5, offset 0x2940 - 0x296f: 0x0400, - 0x2970: 0x0004, 0x2971: 0x0004, 0x2972: 0x0004, 0x2973: 0x0004, 0x2974: 0x0004, 0x2975: 0x0004, - 0x2976: 0x0004, 0x2978: 0x0004, 0x2979: 0x0004, 0x297a: 0x0004, 0x297b: 0x0004, - 0x297c: 0x0004, 0x297d: 0x0004, 0x297e: 0x0400, 0x297f: 0x0004, + 0x2940: 0x2000, 0x2941: 0x0800, 0x2942: 0x2000, 0x2943: 0x0024, // Block 0xa6, offset 0x2980 - 0x2992: 0x0004, 0x2993: 0x0004, 0x2994: 0x0004, 0x2995: 0x0004, 0x2996: 0x0004, 0x2997: 0x0004, - 0x2998: 0x0004, 0x2999: 0x0004, 0x299a: 0x0004, 0x299b: 0x0004, 0x299c: 0x0004, 0x299d: 0x0004, - 0x299e: 0x0004, 0x299f: 0x0004, 0x29a0: 0x0004, 0x29a1: 0x0004, 0x29a2: 0x0004, 0x29a3: 0x0004, - 0x29a4: 0x0004, 0x29a5: 0x0004, 0x29a6: 0x0004, 0x29a7: 0x0004, 0x29a9: 0x0400, - 0x29aa: 0x0004, 0x29ab: 0x0004, 0x29ac: 0x0004, 0x29ad: 0x0004, 0x29ae: 0x0004, 0x29af: 0x0004, - 0x29b0: 0x0004, 0x29b1: 0x0400, 0x29b2: 0x0004, 0x29b3: 0x0004, 0x29b4: 0x0400, 0x29b5: 0x0004, - 0x29b6: 0x0004, + 0x2991: 0x2000, + 0x2992: 0x2000, 0x2993: 0x2000, 0x2994: 0x0024, 0x2995: 0x0024, 0x2996: 0x0024, 0x2997: 0x0024, + 0x299a: 0x0024, 0x299b: 0x0024, 0x299c: 0x2000, 0x299d: 0x2000, + 0x299e: 0x2000, 0x299f: 0x2000, 0x29a0: 0x0024, + 0x29a4: 0x2000, // Block 0xa7, offset 0x29c0 - 0x29f1: 0x0004, 0x29f2: 0x0004, 0x29f3: 0x0004, 0x29f4: 0x0004, 0x29f5: 0x0004, - 0x29f6: 0x0004, 0x29fa: 0x0004, - 0x29fc: 0x0004, 0x29fd: 0x0004, 0x29ff: 0x0004, + 0x29c0: 0x0010, 0x29c1: 0x0024, 0x29c2: 0x0024, 0x29c3: 0x0024, 0x29c4: 0x0024, 0x29c5: 0x0024, + 0x29c6: 0x0024, 0x29c7: 0x0024, 0x29c8: 0x0024, 0x29c9: 0x0024, 0x29ca: 0x0024, 0x29cb: 0x0010, + 0x29cc: 0x0010, 0x29cd: 0x0010, 0x29ce: 0x0010, 0x29cf: 0x0010, 0x29d0: 0x0010, 0x29d1: 0x0010, + 0x29d2: 0x0010, 0x29d3: 0x0010, 0x29d4: 0x0010, 0x29d5: 0x0010, 0x29d6: 0x0010, 0x29d7: 0x0010, + 0x29d8: 0x0010, 0x29d9: 0x0010, 0x29da: 0x0010, 0x29db: 0x0010, 0x29dc: 0x0010, 0x29dd: 0x0010, + 0x29de: 0x0010, 0x29df: 0x0010, 0x29e0: 0x0010, 0x29e1: 0x0010, 0x29e2: 0x0010, 0x29e3: 0x0010, + 0x29e4: 0x0010, 0x29e5: 0x0010, 0x29e6: 0x0010, 0x29e7: 0x0010, 0x29e8: 0x0010, 0x29e9: 0x0010, + 0x29ea: 0x0010, 0x29eb: 0x0010, 0x29ec: 0x0010, 0x29ed: 0x0010, 0x29ee: 0x0010, 0x29ef: 0x0010, + 0x29f0: 0x0010, 0x29f1: 0x0010, 0x29f2: 0x0010, 0x29f3: 0x0024, 0x29f4: 0x0024, 0x29f5: 0x0024, + 0x29f6: 0x0024, 0x29f7: 0x0024, 0x29f8: 0x0024, 0x29f9: 0x2000, 0x29fb: 0x0024, + 0x29fc: 0x0024, 0x29fd: 0x0024, 0x29fe: 0x0024, // Block 0xa8, offset 0x2a00 - 0x2a00: 0x0004, 0x2a01: 0x0004, 0x2a02: 0x0004, 0x2a03: 0x0004, 0x2a04: 0x0004, 0x2a05: 0x0004, - 0x2a06: 0x0100, 0x2a07: 0x0004, + 0x2a07: 0x0044, + 0x2a10: 0x0010, 0x2a11: 0x0024, + 0x2a12: 0x0024, 0x2a13: 0x0024, 0x2a14: 0x0024, 0x2a15: 0x0024, 0x2a16: 0x0024, 0x2a17: 0x2000, + 0x2a18: 0x2000, 0x2a19: 0x0024, 0x2a1a: 0x0024, 0x2a1b: 0x0024, 0x2a1c: 0x0010, 0x2a1d: 0x0010, + 0x2a1e: 0x0010, 0x2a1f: 0x0010, 0x2a20: 0x0010, 0x2a21: 0x0010, 0x2a22: 0x0010, 0x2a23: 0x0010, + 0x2a24: 0x0010, 0x2a25: 0x0010, 0x2a26: 0x0010, 0x2a27: 0x0010, 0x2a28: 0x0010, 0x2a29: 0x0010, + 0x2a2a: 0x0010, 0x2a2b: 0x0010, 0x2a2c: 0x0010, 0x2a2d: 0x0010, 0x2a2e: 0x0010, 0x2a2f: 0x0010, + 0x2a30: 0x0010, 0x2a31: 0x0010, 0x2a32: 0x0010, 0x2a33: 0x0010, 0x2a34: 0x0010, 0x2a35: 0x0010, + 0x2a36: 0x0010, 0x2a37: 0x0010, 0x2a38: 0x0010, 0x2a39: 0x0010, 0x2a3a: 0x0010, 0x2a3b: 0x0010, + 0x2a3c: 0x0010, 0x2a3d: 0x0010, 0x2a3e: 0x0010, 0x2a3f: 0x0010, // Block 0xa9, offset 0x2a40 - 0x2a4a: 0x0400, 0x2a4b: 0x0400, - 0x2a4c: 0x0400, 0x2a4d: 0x0400, 0x2a4e: 0x0400, 0x2a50: 0x0004, 0x2a51: 0x0004, - 0x2a53: 0x0400, 0x2a54: 0x0400, 0x2a55: 0x0004, 0x2a56: 0x0400, 0x2a57: 0x0004, + 0x2a40: 0x0010, 0x2a41: 0x0010, 0x2a42: 0x0010, 0x2a43: 0x0010, 0x2a44: 0x0800, 0x2a45: 0x0800, + 0x2a46: 0x0800, 0x2a47: 0x0800, 0x2a48: 0x0800, 0x2a49: 0x0800, 0x2a4a: 0x0024, 0x2a4b: 0x0024, + 0x2a4c: 0x0024, 0x2a4d: 0x0024, 0x2a4e: 0x0024, 0x2a4f: 0x0024, 0x2a50: 0x0024, 0x2a51: 0x0024, + 0x2a52: 0x0024, 0x2a53: 0x0024, 0x2a54: 0x0024, 0x2a55: 0x0024, 0x2a56: 0x0024, 0x2a57: 0x2000, + 0x2a58: 0x0024, 0x2a59: 0x0044, // Block 0xaa, offset 0x2a80 - 0x2ab3: 0x0004, 0x2ab4: 0x0004, 0x2ab5: 0x0400, - 0x2ab6: 0x0400, + 0x2aa0: 0x0024, 0x2aa1: 0x2000, 0x2aa2: 0x0024, 0x2aa3: 0x0024, + 0x2aa4: 0x0024, 0x2aa5: 0x2000, 0x2aa6: 0x0024, 0x2aa7: 0x2000, // Block 0xab, offset 0x2ac0 - 0x2ac0: 0x0004, 0x2ac1: 0x0004, 0x2ac2: 0x0100, 0x2ac3: 0x0400, - 0x2af4: 0x0400, 0x2af5: 0x0400, - 0x2af6: 0x0004, 0x2af7: 0x0004, 0x2af8: 0x0004, 0x2af9: 0x0004, 0x2afa: 0x0004, - 0x2afe: 0x0400, 0x2aff: 0x0400, + 0x2aef: 0x2000, + 0x2af0: 0x0024, 0x2af1: 0x0024, 0x2af2: 0x0024, 0x2af3: 0x0024, 0x2af4: 0x0024, 0x2af5: 0x0024, + 0x2af6: 0x0024, 0x2af8: 0x0024, 0x2af9: 0x0024, 0x2afa: 0x0024, 0x2afb: 0x0024, + 0x2afc: 0x0024, 0x2afd: 0x0024, 0x2afe: 0x2000, 0x2aff: 0x0024, // Block 0xac, offset 0x2b00 - 0x2b00: 0x0004, 0x2b01: 0x0400, 0x2b02: 0x0004, + 0x2b12: 0x0024, 0x2b13: 0x0024, 0x2b14: 0x0024, 0x2b15: 0x0024, 0x2b16: 0x0024, 0x2b17: 0x0024, + 0x2b18: 0x0024, 0x2b19: 0x0024, 0x2b1a: 0x0024, 0x2b1b: 0x0024, 0x2b1c: 0x0024, 0x2b1d: 0x0024, + 0x2b1e: 0x0024, 0x2b1f: 0x0024, 0x2b20: 0x0024, 0x2b21: 0x0024, 0x2b22: 0x0024, 0x2b23: 0x0024, + 0x2b24: 0x0024, 0x2b25: 0x0024, 0x2b26: 0x0024, 0x2b27: 0x0024, 0x2b29: 0x2000, + 0x2b2a: 0x0024, 0x2b2b: 0x0024, 0x2b2c: 0x0024, 0x2b2d: 0x0024, 0x2b2e: 0x0024, 0x2b2f: 0x0024, + 0x2b30: 0x0024, 0x2b31: 0x2000, 0x2b32: 0x0024, 0x2b33: 0x0024, 0x2b34: 0x2000, 0x2b35: 0x0024, + 0x2b36: 0x0024, // Block 0xad, offset 0x2b40 - 0x2b70: 0x0002, 0x2b71: 0x0002, 0x2b72: 0x0002, 0x2b73: 0x0002, 0x2b74: 0x0002, 0x2b75: 0x0002, - 0x2b76: 0x0002, 0x2b77: 0x0002, 0x2b78: 0x0002, 0x2b79: 0x0002, 0x2b7a: 0x0002, 0x2b7b: 0x0002, - 0x2b7c: 0x0002, 0x2b7d: 0x0002, 0x2b7e: 0x0002, 0x2b7f: 0x0002, + 0x2b71: 0x0024, 0x2b72: 0x0024, 0x2b73: 0x0024, 0x2b74: 0x0024, 0x2b75: 0x0024, + 0x2b76: 0x0024, 0x2b7a: 0x0024, + 0x2b7c: 0x0024, 0x2b7d: 0x0024, 0x2b7f: 0x0024, // Block 0xae, offset 0x2b80 - 0x2b80: 0x0004, - 0x2b87: 0x0004, 0x2b88: 0x0004, 0x2b89: 0x0004, 0x2b8a: 0x0004, 0x2b8b: 0x0004, - 0x2b8c: 0x0004, 0x2b8d: 0x0004, 0x2b8e: 0x0004, 0x2b8f: 0x0004, 0x2b90: 0x0004, 0x2b91: 0x0004, - 0x2b92: 0x0004, 0x2b93: 0x0004, 0x2b94: 0x0004, 0x2b95: 0x0004, + 0x2b80: 0x0024, 0x2b81: 0x0024, 0x2b82: 0x0024, 0x2b83: 0x0024, 0x2b84: 0x0024, 0x2b85: 0x0024, + 0x2b86: 0x0800, 0x2b87: 0x0024, // Block 0xaf, offset 0x2bc0 - 0x2bf0: 0x0004, 0x2bf1: 0x0004, 0x2bf2: 0x0004, 0x2bf3: 0x0004, 0x2bf4: 0x0004, + 0x2bca: 0x2000, 0x2bcb: 0x2000, + 0x2bcc: 0x2000, 0x2bcd: 0x2000, 0x2bce: 0x2000, 0x2bd0: 0x0024, 0x2bd1: 0x0024, + 0x2bd3: 0x2000, 0x2bd4: 0x2000, 0x2bd5: 0x0024, 0x2bd6: 0x2000, 0x2bd7: 0x0024, // Block 0xb0, offset 0x2c00 - 0x2c30: 0x0004, 0x2c31: 0x0004, 0x2c32: 0x0004, 0x2c33: 0x0004, 0x2c34: 0x0004, 0x2c35: 0x0004, - 0x2c36: 0x0004, + 0x2c33: 0x0024, 0x2c34: 0x0024, 0x2c35: 0x2000, + 0x2c36: 0x2000, // Block 0xb1, offset 0x2c40 - 0x2c4f: 0x0004, 0x2c51: 0x0400, - 0x2c52: 0x0400, 0x2c53: 0x0400, 0x2c54: 0x0400, 0x2c55: 0x0400, 0x2c56: 0x0400, 0x2c57: 0x0400, - 0x2c58: 0x0400, 0x2c59: 0x0400, 0x2c5a: 0x0400, 0x2c5b: 0x0400, 0x2c5c: 0x0400, 0x2c5d: 0x0400, - 0x2c5e: 0x0400, 0x2c5f: 0x0400, 0x2c60: 0x0400, 0x2c61: 0x0400, 0x2c62: 0x0400, 0x2c63: 0x0400, - 0x2c64: 0x0400, 0x2c65: 0x0400, 0x2c66: 0x0400, 0x2c67: 0x0400, 0x2c68: 0x0400, 0x2c69: 0x0400, - 0x2c6a: 0x0400, 0x2c6b: 0x0400, 0x2c6c: 0x0400, 0x2c6d: 0x0400, 0x2c6e: 0x0400, 0x2c6f: 0x0400, - 0x2c70: 0x0400, 0x2c71: 0x0400, 0x2c72: 0x0400, 0x2c73: 0x0400, 0x2c74: 0x0400, 0x2c75: 0x0400, - 0x2c76: 0x0400, 0x2c77: 0x0400, 0x2c78: 0x0400, 0x2c79: 0x0400, 0x2c7a: 0x0400, 0x2c7b: 0x0400, - 0x2c7c: 0x0400, 0x2c7d: 0x0400, 0x2c7e: 0x0400, 0x2c7f: 0x0400, + 0x2c40: 0x0024, 0x2c41: 0x0024, 0x2c42: 0x0800, 0x2c43: 0x2000, 0x2c44: 0x0010, 0x2c45: 0x0010, + 0x2c46: 0x0010, 0x2c47: 0x0010, 0x2c48: 0x0010, 0x2c49: 0x0010, 0x2c4a: 0x0010, 0x2c4b: 0x0010, + 0x2c4c: 0x0010, 0x2c4d: 0x0010, 0x2c4e: 0x0010, 0x2c4f: 0x0010, 0x2c50: 0x0010, + 0x2c52: 0x0010, 0x2c53: 0x0010, 0x2c54: 0x0010, 0x2c55: 0x0010, 0x2c56: 0x0010, 0x2c57: 0x0010, + 0x2c58: 0x0010, 0x2c59: 0x0010, 0x2c5a: 0x0010, 0x2c5b: 0x0010, 0x2c5c: 0x0010, 0x2c5d: 0x0010, + 0x2c5e: 0x0010, 0x2c5f: 0x0010, 0x2c60: 0x0010, 0x2c61: 0x0010, 0x2c62: 0x0010, 0x2c63: 0x0010, + 0x2c64: 0x0010, 0x2c65: 0x0010, 0x2c66: 0x0010, 0x2c67: 0x0010, 0x2c68: 0x0010, 0x2c69: 0x0010, + 0x2c6a: 0x0010, 0x2c6b: 0x0010, 0x2c6c: 0x0010, 0x2c6d: 0x0010, 0x2c6e: 0x0010, 0x2c6f: 0x0010, + 0x2c70: 0x0010, 0x2c71: 0x0010, 0x2c72: 0x0010, 0x2c73: 0x0010, 0x2c74: 0x2000, 0x2c75: 0x2000, + 0x2c76: 0x0024, 0x2c77: 0x0024, 0x2c78: 0x0024, 0x2c79: 0x0024, 0x2c7a: 0x0024, + 0x2c7e: 0x2000, 0x2c7f: 0x2000, // Block 0xb2, offset 0x2c80 - 0x2c80: 0x0400, 0x2c81: 0x0400, 0x2c82: 0x0400, 0x2c83: 0x0400, 0x2c84: 0x0400, 0x2c85: 0x0400, - 0x2c86: 0x0400, 0x2c87: 0x0400, - 0x2c8f: 0x0004, 0x2c90: 0x0004, 0x2c91: 0x0004, - 0x2c92: 0x0004, + 0x2c80: 0x0024, 0x2c81: 0x0024, 0x2c82: 0x0044, + 0x2c9a: 0x0024, // Block 0xb3, offset 0x2cc0 - 0x2ce4: 0x0004, - 0x2cf0: 0x0400, 0x2cf1: 0x0400, + 0x2cf0: 0x0002, 0x2cf1: 0x0002, 0x2cf2: 0x0002, 0x2cf3: 0x0002, 0x2cf4: 0x0002, 0x2cf5: 0x0002, + 0x2cf6: 0x0002, 0x2cf7: 0x0002, 0x2cf8: 0x0002, 0x2cf9: 0x0002, 0x2cfa: 0x0002, 0x2cfb: 0x0002, + 0x2cfc: 0x0002, 0x2cfd: 0x0002, 0x2cfe: 0x0002, 0x2cff: 0x0002, // Block 0xb4, offset 0x2d00 - 0x2d1d: 0x0004, - 0x2d1e: 0x0004, 0x2d20: 0x0002, 0x2d21: 0x0002, 0x2d22: 0x0002, 0x2d23: 0x0002, + 0x2d00: 0x0024, + 0x2d07: 0x0024, 0x2d08: 0x0024, 0x2d09: 0x0024, 0x2d0a: 0x0024, 0x2d0b: 0x0024, + 0x2d0c: 0x0024, 0x2d0d: 0x0024, 0x2d0e: 0x0024, 0x2d0f: 0x0024, 0x2d10: 0x0024, 0x2d11: 0x0024, + 0x2d12: 0x0024, 0x2d13: 0x0024, 0x2d14: 0x0024, 0x2d15: 0x0024, // Block 0xb5, offset 0x2d40 - 0x2d40: 0x0004, 0x2d41: 0x0004, 0x2d42: 0x0004, 0x2d43: 0x0004, 0x2d44: 0x0004, 0x2d45: 0x0004, - 0x2d46: 0x0004, 0x2d47: 0x0004, 0x2d48: 0x0004, 0x2d49: 0x0004, 0x2d4a: 0x0004, 0x2d4b: 0x0004, - 0x2d4c: 0x0004, 0x2d4d: 0x0004, 0x2d4e: 0x0004, 0x2d4f: 0x0004, 0x2d50: 0x0004, 0x2d51: 0x0004, - 0x2d52: 0x0004, 0x2d53: 0x0004, 0x2d54: 0x0004, 0x2d55: 0x0004, 0x2d56: 0x0004, 0x2d57: 0x0004, - 0x2d58: 0x0004, 0x2d59: 0x0004, 0x2d5a: 0x0004, 0x2d5b: 0x0004, 0x2d5c: 0x0004, 0x2d5d: 0x0004, - 0x2d5e: 0x0004, 0x2d5f: 0x0004, 0x2d60: 0x0004, 0x2d61: 0x0004, 0x2d62: 0x0004, 0x2d63: 0x0004, - 0x2d64: 0x0004, 0x2d65: 0x0004, 0x2d66: 0x0004, 0x2d67: 0x0004, 0x2d68: 0x0004, 0x2d69: 0x0004, - 0x2d6a: 0x0004, 0x2d6b: 0x0004, 0x2d6c: 0x0004, 0x2d6d: 0x0004, - 0x2d70: 0x0004, 0x2d71: 0x0004, 0x2d72: 0x0004, 0x2d73: 0x0004, 0x2d74: 0x0004, 0x2d75: 0x0004, - 0x2d76: 0x0004, 0x2d77: 0x0004, 0x2d78: 0x0004, 0x2d79: 0x0004, 0x2d7a: 0x0004, 0x2d7b: 0x0004, - 0x2d7c: 0x0004, 0x2d7d: 0x0004, 0x2d7e: 0x0004, 0x2d7f: 0x0004, + 0x2d5e: 0x0024, 0x2d5f: 0x0024, 0x2d60: 0x0024, 0x2d61: 0x0024, 0x2d62: 0x0024, 0x2d63: 0x0024, + 0x2d64: 0x0024, 0x2d65: 0x0024, 0x2d66: 0x0024, 0x2d67: 0x0024, 0x2d68: 0x0024, 0x2d69: 0x0024, + 0x2d6a: 0x2000, 0x2d6b: 0x2000, 0x2d6c: 0x2000, 0x2d6d: 0x0024, 0x2d6e: 0x0024, 0x2d6f: 0x0024, // Block 0xb6, offset 0x2d80 - 0x2d80: 0x0004, 0x2d81: 0x0004, 0x2d82: 0x0004, 0x2d83: 0x0004, 0x2d84: 0x0004, 0x2d85: 0x0004, - 0x2d86: 0x0004, + 0x2db0: 0x0024, 0x2db1: 0x0024, 0x2db2: 0x0024, 0x2db3: 0x0024, 0x2db4: 0x0024, // Block 0xb7, offset 0x2dc0 - 0x2de5: 0x0004, 0x2de6: 0x0400, 0x2de7: 0x0004, 0x2de8: 0x0004, 0x2de9: 0x0004, - 0x2ded: 0x0400, 0x2dee: 0x0004, 0x2def: 0x0004, - 0x2df0: 0x0004, 0x2df1: 0x0004, 0x2df2: 0x0004, 0x2df3: 0x0002, 0x2df4: 0x0002, 0x2df5: 0x0002, - 0x2df6: 0x0002, 0x2df7: 0x0002, 0x2df8: 0x0002, 0x2df9: 0x0002, 0x2dfa: 0x0002, 0x2dfb: 0x0004, - 0x2dfc: 0x0004, 0x2dfd: 0x0004, 0x2dfe: 0x0004, 0x2dff: 0x0004, + 0x2df0: 0x0024, 0x2df1: 0x0024, 0x2df2: 0x0024, 0x2df3: 0x0024, 0x2df4: 0x0024, 0x2df5: 0x0024, + 0x2df6: 0x0024, // Block 0xb8, offset 0x2e00 - 0x2e00: 0x0004, 0x2e01: 0x0004, 0x2e02: 0x0004, 0x2e05: 0x0004, - 0x2e06: 0x0004, 0x2e07: 0x0004, 0x2e08: 0x0004, 0x2e09: 0x0004, 0x2e0a: 0x0004, 0x2e0b: 0x0004, - 0x2e2a: 0x0004, 0x2e2b: 0x0004, 0x2e2c: 0x0004, 0x2e2d: 0x0004, + 0x2e23: 0x8000, + 0x2e27: 0x8000, 0x2e28: 0x8000, 0x2e29: 0x8000, + 0x2e2a: 0x8000, // Block 0xb9, offset 0x2e40 - 0x2e42: 0x0004, 0x2e43: 0x0004, 0x2e44: 0x0004, + 0x2e4f: 0x0024, 0x2e51: 0x2000, + 0x2e52: 0x2000, 0x2e53: 0x2000, 0x2e54: 0x2000, 0x2e55: 0x2000, 0x2e56: 0x2000, 0x2e57: 0x2000, + 0x2e58: 0x2000, 0x2e59: 0x2000, 0x2e5a: 0x2000, 0x2e5b: 0x2000, 0x2e5c: 0x2000, 0x2e5d: 0x2000, + 0x2e5e: 0x2000, 0x2e5f: 0x2000, 0x2e60: 0x2000, 0x2e61: 0x2000, 0x2e62: 0x2000, 0x2e63: 0x2000, + 0x2e64: 0x2000, 0x2e65: 0x2000, 0x2e66: 0x2000, 0x2e67: 0x2000, 0x2e68: 0x2000, 0x2e69: 0x2000, + 0x2e6a: 0x2000, 0x2e6b: 0x2000, 0x2e6c: 0x2000, 0x2e6d: 0x2000, 0x2e6e: 0x2000, 0x2e6f: 0x2000, + 0x2e70: 0x2000, 0x2e71: 0x2000, 0x2e72: 0x2000, 0x2e73: 0x2000, 0x2e74: 0x2000, 0x2e75: 0x2000, + 0x2e76: 0x2000, 0x2e77: 0x2000, 0x2e78: 0x2000, 0x2e79: 0x2000, 0x2e7a: 0x2000, 0x2e7b: 0x2000, + 0x2e7c: 0x2000, 0x2e7d: 0x2000, 0x2e7e: 0x2000, 0x2e7f: 0x2000, // Block 0xba, offset 0x2e80 - 0x2e80: 0x0004, 0x2e81: 0x0004, 0x2e82: 0x0004, 0x2e83: 0x0004, 0x2e84: 0x0004, 0x2e85: 0x0004, - 0x2e86: 0x0004, 0x2e87: 0x0004, 0x2e88: 0x0004, 0x2e89: 0x0004, 0x2e8a: 0x0004, 0x2e8b: 0x0004, - 0x2e8c: 0x0004, 0x2e8d: 0x0004, 0x2e8e: 0x0004, 0x2e8f: 0x0004, 0x2e90: 0x0004, 0x2e91: 0x0004, - 0x2e92: 0x0004, 0x2e93: 0x0004, 0x2e94: 0x0004, 0x2e95: 0x0004, 0x2e96: 0x0004, 0x2e97: 0x0004, - 0x2e98: 0x0004, 0x2e99: 0x0004, 0x2e9a: 0x0004, 0x2e9b: 0x0004, 0x2e9c: 0x0004, 0x2e9d: 0x0004, - 0x2e9e: 0x0004, 0x2e9f: 0x0004, 0x2ea0: 0x0004, 0x2ea1: 0x0004, 0x2ea2: 0x0004, 0x2ea3: 0x0004, - 0x2ea4: 0x0004, 0x2ea5: 0x0004, 0x2ea6: 0x0004, 0x2ea7: 0x0004, 0x2ea8: 0x0004, 0x2ea9: 0x0004, - 0x2eaa: 0x0004, 0x2eab: 0x0004, 0x2eac: 0x0004, 0x2ead: 0x0004, 0x2eae: 0x0004, 0x2eaf: 0x0004, - 0x2eb0: 0x0004, 0x2eb1: 0x0004, 0x2eb2: 0x0004, 0x2eb3: 0x0004, 0x2eb4: 0x0004, 0x2eb5: 0x0004, - 0x2eb6: 0x0004, 0x2ebb: 0x0004, - 0x2ebc: 0x0004, 0x2ebd: 0x0004, 0x2ebe: 0x0004, 0x2ebf: 0x0004, + 0x2e80: 0x2000, 0x2e81: 0x2000, 0x2e82: 0x2000, 0x2e83: 0x2000, 0x2e84: 0x2000, 0x2e85: 0x2000, + 0x2e86: 0x2000, 0x2e87: 0x2000, + 0x2e8f: 0x0024, 0x2e90: 0x0024, 0x2e91: 0x0024, + 0x2e92: 0x0024, // Block 0xbb, offset 0x2ec0 - 0x2ec0: 0x0004, 0x2ec1: 0x0004, 0x2ec2: 0x0004, 0x2ec3: 0x0004, 0x2ec4: 0x0004, 0x2ec5: 0x0004, - 0x2ec6: 0x0004, 0x2ec7: 0x0004, 0x2ec8: 0x0004, 0x2ec9: 0x0004, 0x2eca: 0x0004, 0x2ecb: 0x0004, - 0x2ecc: 0x0004, 0x2ecd: 0x0004, 0x2ece: 0x0004, 0x2ecf: 0x0004, 0x2ed0: 0x0004, 0x2ed1: 0x0004, - 0x2ed2: 0x0004, 0x2ed3: 0x0004, 0x2ed4: 0x0004, 0x2ed5: 0x0004, 0x2ed6: 0x0004, 0x2ed7: 0x0004, - 0x2ed8: 0x0004, 0x2ed9: 0x0004, 0x2eda: 0x0004, 0x2edb: 0x0004, 0x2edc: 0x0004, 0x2edd: 0x0004, - 0x2ede: 0x0004, 0x2edf: 0x0004, 0x2ee0: 0x0004, 0x2ee1: 0x0004, 0x2ee2: 0x0004, 0x2ee3: 0x0004, - 0x2ee4: 0x0004, 0x2ee5: 0x0004, 0x2ee6: 0x0004, 0x2ee7: 0x0004, 0x2ee8: 0x0004, 0x2ee9: 0x0004, - 0x2eea: 0x0004, 0x2eeb: 0x0004, 0x2eec: 0x0004, - 0x2ef5: 0x0004, + 0x2ee4: 0x0024, + 0x2ef0: 0x0024, 0x2ef1: 0x0024, // Block 0xbc, offset 0x2f00 - 0x2f04: 0x0004, - 0x2f1b: 0x0004, 0x2f1c: 0x0004, 0x2f1d: 0x0004, - 0x2f1e: 0x0004, 0x2f1f: 0x0004, 0x2f21: 0x0004, 0x2f22: 0x0004, 0x2f23: 0x0004, - 0x2f24: 0x0004, 0x2f25: 0x0004, 0x2f26: 0x0004, 0x2f27: 0x0004, 0x2f28: 0x0004, 0x2f29: 0x0004, - 0x2f2a: 0x0004, 0x2f2b: 0x0004, 0x2f2c: 0x0004, 0x2f2d: 0x0004, 0x2f2e: 0x0004, 0x2f2f: 0x0004, + 0x2f1d: 0x0024, + 0x2f1e: 0x0024, 0x2f20: 0x0002, 0x2f21: 0x0002, 0x2f22: 0x0002, 0x2f23: 0x0002, // Block 0xbd, offset 0x2f40 - 0x2f40: 0x0004, 0x2f41: 0x0004, 0x2f42: 0x0004, 0x2f43: 0x0004, 0x2f44: 0x0004, 0x2f45: 0x0004, - 0x2f46: 0x0004, 0x2f48: 0x0004, 0x2f49: 0x0004, 0x2f4a: 0x0004, 0x2f4b: 0x0004, - 0x2f4c: 0x0004, 0x2f4d: 0x0004, 0x2f4e: 0x0004, 0x2f4f: 0x0004, 0x2f50: 0x0004, 0x2f51: 0x0004, - 0x2f52: 0x0004, 0x2f53: 0x0004, 0x2f54: 0x0004, 0x2f55: 0x0004, 0x2f56: 0x0004, 0x2f57: 0x0004, - 0x2f58: 0x0004, 0x2f5b: 0x0004, 0x2f5c: 0x0004, 0x2f5d: 0x0004, - 0x2f5e: 0x0004, 0x2f5f: 0x0004, 0x2f60: 0x0004, 0x2f61: 0x0004, 0x2f63: 0x0004, - 0x2f64: 0x0004, 0x2f66: 0x0004, 0x2f67: 0x0004, 0x2f68: 0x0004, 0x2f69: 0x0004, - 0x2f6a: 0x0004, + 0x2f40: 0x0024, 0x2f41: 0x0024, 0x2f42: 0x0024, 0x2f43: 0x0024, 0x2f44: 0x0024, 0x2f45: 0x0024, + 0x2f46: 0x0024, 0x2f47: 0x0024, 0x2f48: 0x0024, 0x2f49: 0x0024, 0x2f4a: 0x0024, 0x2f4b: 0x0024, + 0x2f4c: 0x0024, 0x2f4d: 0x0024, 0x2f4e: 0x0024, 0x2f4f: 0x0024, 0x2f50: 0x0024, 0x2f51: 0x0024, + 0x2f52: 0x0024, 0x2f53: 0x0024, 0x2f54: 0x0024, 0x2f55: 0x0024, 0x2f56: 0x0024, 0x2f57: 0x0024, + 0x2f58: 0x0024, 0x2f59: 0x0024, 0x2f5a: 0x0024, 0x2f5b: 0x0024, 0x2f5c: 0x0024, 0x2f5d: 0x0024, + 0x2f5e: 0x0024, 0x2f5f: 0x0024, 0x2f60: 0x0024, 0x2f61: 0x0024, 0x2f62: 0x0024, 0x2f63: 0x0024, + 0x2f64: 0x0024, 0x2f65: 0x0024, 0x2f66: 0x0024, 0x2f67: 0x0024, 0x2f68: 0x0024, 0x2f69: 0x0024, + 0x2f6a: 0x0024, 0x2f6b: 0x0024, 0x2f6c: 0x0024, 0x2f6d: 0x0024, + 0x2f70: 0x0024, 0x2f71: 0x0024, 0x2f72: 0x0024, 0x2f73: 0x0024, 0x2f74: 0x0024, 0x2f75: 0x0024, + 0x2f76: 0x0024, 0x2f77: 0x0024, 0x2f78: 0x0024, 0x2f79: 0x0024, 0x2f7a: 0x0024, 0x2f7b: 0x0024, + 0x2f7c: 0x0024, 0x2f7d: 0x0024, 0x2f7e: 0x0024, 0x2f7f: 0x0024, // Block 0xbe, offset 0x2f80 - 0x2f8f: 0x0004, + 0x2f80: 0x0024, 0x2f81: 0x0024, 0x2f82: 0x0024, 0x2f83: 0x0024, 0x2f84: 0x0024, 0x2f85: 0x0024, + 0x2f86: 0x0024, // Block 0xbf, offset 0x2fc0 - 0x2fee: 0x0004, + 0x2fe5: 0x0024, 0x2fe6: 0x0024, 0x2fe7: 0x0024, 0x2fe8: 0x0024, 0x2fe9: 0x0024, + 0x2fed: 0x0024, 0x2fee: 0x0024, 0x2fef: 0x0024, + 0x2ff0: 0x0024, 0x2ff1: 0x0024, 0x2ff2: 0x0024, 0x2ff3: 0x0002, 0x2ff4: 0x0002, 0x2ff5: 0x0002, + 0x2ff6: 0x0002, 0x2ff7: 0x0002, 0x2ff8: 0x0002, 0x2ff9: 0x0002, 0x2ffa: 0x0002, 0x2ffb: 0x0024, + 0x2ffc: 0x0024, 0x2ffd: 0x0024, 0x2ffe: 0x0024, 0x2fff: 0x0024, // Block 0xc0, offset 0x3000 - 0x302c: 0x0004, 0x302d: 0x0004, 0x302e: 0x0004, 0x302f: 0x0004, + 0x3000: 0x0024, 0x3001: 0x0024, 0x3002: 0x0024, 0x3005: 0x0024, + 0x3006: 0x0024, 0x3007: 0x0024, 0x3008: 0x0024, 0x3009: 0x0024, 0x300a: 0x0024, 0x300b: 0x0024, + 0x302a: 0x0024, 0x302b: 0x0024, 0x302c: 0x0024, 0x302d: 0x0024, // Block 0xc1, offset 0x3040 - 0x3050: 0x0004, 0x3051: 0x0004, - 0x3052: 0x0004, 0x3053: 0x0004, 0x3054: 0x0004, 0x3055: 0x0004, 0x3056: 0x0004, + 0x3042: 0x0024, 0x3043: 0x0024, 0x3044: 0x0024, // Block 0xc2, offset 0x3080 - 0x3084: 0x0004, 0x3085: 0x0004, - 0x3086: 0x0004, 0x3087: 0x0004, 0x3088: 0x0004, 0x3089: 0x0004, 0x308a: 0x0004, + 0x3080: 0x0024, 0x3081: 0x0024, 0x3082: 0x0024, 0x3083: 0x0024, 0x3084: 0x0024, 0x3085: 0x0024, + 0x3086: 0x0024, 0x3087: 0x0024, 0x3088: 0x0024, 0x3089: 0x0024, 0x308a: 0x0024, 0x308b: 0x0024, + 0x308c: 0x0024, 0x308d: 0x0024, 0x308e: 0x0024, 0x308f: 0x0024, 0x3090: 0x0024, 0x3091: 0x0024, + 0x3092: 0x0024, 0x3093: 0x0024, 0x3094: 0x0024, 0x3095: 0x0024, 0x3096: 0x0024, 0x3097: 0x0024, + 0x3098: 0x0024, 0x3099: 0x0024, 0x309a: 0x0024, 0x309b: 0x0024, 0x309c: 0x0024, 0x309d: 0x0024, + 0x309e: 0x0024, 0x309f: 0x0024, 0x30a0: 0x0024, 0x30a1: 0x0024, 0x30a2: 0x0024, 0x30a3: 0x0024, + 0x30a4: 0x0024, 0x30a5: 0x0024, 0x30a6: 0x0024, 0x30a7: 0x0024, 0x30a8: 0x0024, 0x30a9: 0x0024, + 0x30aa: 0x0024, 0x30ab: 0x0024, 0x30ac: 0x0024, 0x30ad: 0x0024, 0x30ae: 0x0024, 0x30af: 0x0024, + 0x30b0: 0x0024, 0x30b1: 0x0024, 0x30b2: 0x0024, 0x30b3: 0x0024, 0x30b4: 0x0024, 0x30b5: 0x0024, + 0x30b6: 0x0024, 0x30bb: 0x0024, + 0x30bc: 0x0024, 0x30bd: 0x0024, 0x30be: 0x0024, 0x30bf: 0x0024, // Block 0xc3, offset 0x30c0 - 0x30cd: 0x0008, 0x30ce: 0x0008, 0x30cf: 0x0008, - 0x30ef: 0x0008, + 0x30c0: 0x0024, 0x30c1: 0x0024, 0x30c2: 0x0024, 0x30c3: 0x0024, 0x30c4: 0x0024, 0x30c5: 0x0024, + 0x30c6: 0x0024, 0x30c7: 0x0024, 0x30c8: 0x0024, 0x30c9: 0x0024, 0x30ca: 0x0024, 0x30cb: 0x0024, + 0x30cc: 0x0024, 0x30cd: 0x0024, 0x30ce: 0x0024, 0x30cf: 0x0024, 0x30d0: 0x0024, 0x30d1: 0x0024, + 0x30d2: 0x0024, 0x30d3: 0x0024, 0x30d4: 0x0024, 0x30d5: 0x0024, 0x30d6: 0x0024, 0x30d7: 0x0024, + 0x30d8: 0x0024, 0x30d9: 0x0024, 0x30da: 0x0024, 0x30db: 0x0024, 0x30dc: 0x0024, 0x30dd: 0x0024, + 0x30de: 0x0024, 0x30df: 0x0024, 0x30e0: 0x0024, 0x30e1: 0x0024, 0x30e2: 0x0024, 0x30e3: 0x0024, + 0x30e4: 0x0024, 0x30e5: 0x0024, 0x30e6: 0x0024, 0x30e7: 0x0024, 0x30e8: 0x0024, 0x30e9: 0x0024, + 0x30ea: 0x0024, 0x30eb: 0x0024, 0x30ec: 0x0024, + 0x30f5: 0x0024, // Block 0xc4, offset 0x3100 - 0x312c: 0x0008, 0x312d: 0x0008, 0x312e: 0x0008, 0x312f: 0x0008, - 0x3130: 0x0008, 0x3131: 0x0008, - 0x313e: 0x0008, 0x313f: 0x0008, + 0x3104: 0x0024, + 0x311b: 0x0024, 0x311c: 0x0024, 0x311d: 0x0024, + 0x311e: 0x0024, 0x311f: 0x0024, 0x3121: 0x0024, 0x3122: 0x0024, 0x3123: 0x0024, + 0x3124: 0x0024, 0x3125: 0x0024, 0x3126: 0x0024, 0x3127: 0x0024, 0x3128: 0x0024, 0x3129: 0x0024, + 0x312a: 0x0024, 0x312b: 0x0024, 0x312c: 0x0024, 0x312d: 0x0024, 0x312e: 0x0024, 0x312f: 0x0024, // Block 0xc5, offset 0x3140 - 0x314e: 0x0008, 0x3151: 0x0008, - 0x3152: 0x0008, 0x3153: 0x0008, 0x3154: 0x0008, 0x3155: 0x0008, 0x3156: 0x0008, 0x3157: 0x0008, - 0x3158: 0x0008, 0x3159: 0x0008, 0x315a: 0x0008, - 0x316d: 0x0008, 0x316e: 0x0008, 0x316f: 0x0008, - 0x3170: 0x0008, 0x3171: 0x0008, 0x3172: 0x0008, 0x3173: 0x0008, 0x3174: 0x0008, 0x3175: 0x0008, - 0x3176: 0x0008, 0x3177: 0x0008, 0x3178: 0x0008, 0x3179: 0x0008, 0x317a: 0x0008, 0x317b: 0x0008, - 0x317c: 0x0008, 0x317d: 0x0008, 0x317e: 0x0008, 0x317f: 0x0008, + 0x3140: 0x0024, 0x3141: 0x0024, 0x3142: 0x0024, 0x3143: 0x0024, 0x3144: 0x0024, 0x3145: 0x0024, + 0x3146: 0x0024, 0x3148: 0x0024, 0x3149: 0x0024, 0x314a: 0x0024, 0x314b: 0x0024, + 0x314c: 0x0024, 0x314d: 0x0024, 0x314e: 0x0024, 0x314f: 0x0024, 0x3150: 0x0024, 0x3151: 0x0024, + 0x3152: 0x0024, 0x3153: 0x0024, 0x3154: 0x0024, 0x3155: 0x0024, 0x3156: 0x0024, 0x3157: 0x0024, + 0x3158: 0x0024, 0x315b: 0x0024, 0x315c: 0x0024, 0x315d: 0x0024, + 0x315e: 0x0024, 0x315f: 0x0024, 0x3160: 0x0024, 0x3161: 0x0024, 0x3163: 0x0024, + 0x3164: 0x0024, 0x3166: 0x0024, 0x3167: 0x0024, 0x3168: 0x0024, 0x3169: 0x0024, + 0x316a: 0x0024, // Block 0xc6, offset 0x3180 - 0x3180: 0x0008, 0x3181: 0x0008, 0x3182: 0x0008, 0x3183: 0x0008, 0x3184: 0x0008, 0x3185: 0x0008, - 0x3186: 0x0008, 0x3187: 0x0008, 0x3188: 0x0008, 0x3189: 0x0008, 0x318a: 0x0008, 0x318b: 0x0008, - 0x318c: 0x0008, 0x318d: 0x0008, 0x318e: 0x0008, 0x318f: 0x0008, 0x3190: 0x0008, 0x3191: 0x0008, - 0x3192: 0x0008, 0x3193: 0x0008, 0x3194: 0x0008, 0x3195: 0x0008, 0x3196: 0x0008, 0x3197: 0x0008, - 0x3198: 0x0008, 0x3199: 0x0008, 0x319a: 0x0008, 0x319b: 0x0008, 0x319c: 0x0008, 0x319d: 0x0008, - 0x319e: 0x0008, 0x319f: 0x0008, 0x31a0: 0x0008, 0x31a1: 0x0008, 0x31a2: 0x0008, 0x31a3: 0x0008, - 0x31a4: 0x0008, 0x31a5: 0x0008, 0x31a6: 0x0200, 0x31a7: 0x0200, 0x31a8: 0x0200, 0x31a9: 0x0200, - 0x31aa: 0x0200, 0x31ab: 0x0200, 0x31ac: 0x0200, 0x31ad: 0x0200, 0x31ae: 0x0200, 0x31af: 0x0200, - 0x31b0: 0x0200, 0x31b1: 0x0200, 0x31b2: 0x0200, 0x31b3: 0x0200, 0x31b4: 0x0200, 0x31b5: 0x0200, - 0x31b6: 0x0200, 0x31b7: 0x0200, 0x31b8: 0x0200, 0x31b9: 0x0200, 0x31ba: 0x0200, 0x31bb: 0x0200, - 0x31bc: 0x0200, 0x31bd: 0x0200, 0x31be: 0x0200, 0x31bf: 0x0200, + 0x318f: 0x0024, // Block 0xc7, offset 0x31c0 - 0x31c1: 0x0008, 0x31c2: 0x0008, 0x31c3: 0x0008, 0x31c4: 0x0008, 0x31c5: 0x0008, - 0x31c6: 0x0008, 0x31c7: 0x0008, 0x31c8: 0x0008, 0x31c9: 0x0008, 0x31ca: 0x0008, 0x31cb: 0x0008, - 0x31cc: 0x0008, 0x31cd: 0x0008, 0x31ce: 0x0008, 0x31cf: 0x0008, - 0x31da: 0x0008, - 0x31ef: 0x0008, - 0x31f2: 0x0008, 0x31f3: 0x0008, 0x31f4: 0x0008, 0x31f5: 0x0008, - 0x31f6: 0x0008, 0x31f7: 0x0008, 0x31f8: 0x0008, 0x31f9: 0x0008, 0x31fa: 0x0008, - 0x31fc: 0x0008, 0x31fd: 0x0008, 0x31fe: 0x0008, 0x31ff: 0x0008, + 0x31ee: 0x0024, // Block 0xc8, offset 0x3200 - 0x3209: 0x0008, 0x320a: 0x0008, 0x320b: 0x0008, - 0x320c: 0x0008, 0x320d: 0x0008, 0x320e: 0x0008, 0x320f: 0x0008, 0x3210: 0x0008, 0x3211: 0x0008, - 0x3212: 0x0008, 0x3213: 0x0008, 0x3214: 0x0008, 0x3215: 0x0008, 0x3216: 0x0008, 0x3217: 0x0008, - 0x3218: 0x0008, 0x3219: 0x0008, 0x321a: 0x0008, 0x321b: 0x0008, 0x321c: 0x0008, 0x321d: 0x0008, - 0x321e: 0x0008, 0x321f: 0x0008, 0x3220: 0x0008, 0x3221: 0x0008, 0x3222: 0x0008, 0x3223: 0x0008, - 0x3224: 0x0008, 0x3225: 0x0008, 0x3226: 0x0008, 0x3227: 0x0008, 0x3228: 0x0008, 0x3229: 0x0008, - 0x322a: 0x0008, 0x322b: 0x0008, 0x322c: 0x0008, 0x322d: 0x0008, 0x322e: 0x0008, 0x322f: 0x0008, - 0x3230: 0x0008, 0x3231: 0x0008, 0x3232: 0x0008, 0x3233: 0x0008, 0x3234: 0x0008, 0x3235: 0x0008, - 0x3236: 0x0008, 0x3237: 0x0008, 0x3238: 0x0008, 0x3239: 0x0008, 0x323a: 0x0008, 0x323b: 0x0008, - 0x323c: 0x0008, 0x323d: 0x0008, 0x323e: 0x0008, 0x323f: 0x0008, + 0x322c: 0x0024, 0x322d: 0x0024, 0x322e: 0x0024, 0x322f: 0x0024, // Block 0xc9, offset 0x3240 - 0x3240: 0x0008, 0x3241: 0x0008, 0x3242: 0x0008, 0x3243: 0x0008, 0x3244: 0x0008, 0x3245: 0x0008, - 0x3246: 0x0008, 0x3247: 0x0008, 0x3248: 0x0008, 0x3249: 0x0008, 0x324a: 0x0008, 0x324b: 0x0008, - 0x324c: 0x0008, 0x324d: 0x0008, 0x324e: 0x0008, 0x324f: 0x0008, 0x3250: 0x0008, 0x3251: 0x0008, - 0x3252: 0x0008, 0x3253: 0x0008, 0x3254: 0x0008, 0x3255: 0x0008, 0x3256: 0x0008, 0x3257: 0x0008, - 0x3258: 0x0008, 0x3259: 0x0008, 0x325a: 0x0008, 0x325b: 0x0008, 0x325c: 0x0008, 0x325d: 0x0008, - 0x325e: 0x0008, 0x325f: 0x0008, 0x3260: 0x0008, 0x3261: 0x0008, 0x3262: 0x0008, 0x3263: 0x0008, - 0x3264: 0x0008, 0x3265: 0x0008, 0x3266: 0x0008, 0x3267: 0x0008, 0x3268: 0x0008, 0x3269: 0x0008, - 0x326a: 0x0008, 0x326b: 0x0008, 0x326c: 0x0008, 0x326d: 0x0008, 0x326e: 0x0008, 0x326f: 0x0008, - 0x3270: 0x0008, 0x3271: 0x0008, 0x3272: 0x0008, 0x3273: 0x0008, 0x3274: 0x0008, 0x3275: 0x0008, - 0x3276: 0x0008, 0x3277: 0x0008, 0x3278: 0x0008, 0x3279: 0x0008, 0x327a: 0x0008, 0x327b: 0x0004, - 0x327c: 0x0004, 0x327d: 0x0004, 0x327e: 0x0004, 0x327f: 0x0004, + 0x326e: 0x0024, 0x326f: 0x0024, // Block 0xca, offset 0x3280 - 0x3280: 0x0008, 0x3281: 0x0008, 0x3282: 0x0008, 0x3283: 0x0008, 0x3284: 0x0008, 0x3285: 0x0008, - 0x3286: 0x0008, 0x3287: 0x0008, 0x3288: 0x0008, 0x3289: 0x0008, 0x328a: 0x0008, 0x328b: 0x0008, - 0x328c: 0x0008, 0x328d: 0x0008, 0x328e: 0x0008, 0x328f: 0x0008, 0x3290: 0x0008, 0x3291: 0x0008, - 0x3292: 0x0008, 0x3293: 0x0008, 0x3294: 0x0008, 0x3295: 0x0008, 0x3296: 0x0008, 0x3297: 0x0008, - 0x3298: 0x0008, 0x3299: 0x0008, 0x329a: 0x0008, 0x329b: 0x0008, 0x329c: 0x0008, 0x329d: 0x0008, - 0x329e: 0x0008, 0x329f: 0x0008, 0x32a0: 0x0008, 0x32a1: 0x0008, 0x32a2: 0x0008, 0x32a3: 0x0008, - 0x32a4: 0x0008, 0x32a5: 0x0008, 0x32a6: 0x0008, 0x32a7: 0x0008, 0x32a8: 0x0008, 0x32a9: 0x0008, - 0x32aa: 0x0008, 0x32ab: 0x0008, 0x32ac: 0x0008, 0x32ad: 0x0008, 0x32ae: 0x0008, 0x32af: 0x0008, - 0x32b0: 0x0008, 0x32b1: 0x0008, 0x32b2: 0x0008, 0x32b3: 0x0008, 0x32b4: 0x0008, 0x32b5: 0x0008, - 0x32b6: 0x0008, 0x32b7: 0x0008, 0x32b8: 0x0008, 0x32b9: 0x0008, 0x32ba: 0x0008, 0x32bb: 0x0008, - 0x32bc: 0x0008, 0x32bd: 0x0008, + 0x32a3: 0x0024, + 0x32a6: 0x0024, + 0x32ae: 0x0024, 0x32af: 0x0024, + 0x32b5: 0x0024, // Block 0xcb, offset 0x32c0 - 0x32c6: 0x0008, 0x32c7: 0x0008, 0x32c8: 0x0008, 0x32c9: 0x0008, 0x32ca: 0x0008, 0x32cb: 0x0008, - 0x32cc: 0x0008, 0x32cd: 0x0008, 0x32ce: 0x0008, 0x32cf: 0x0008, 0x32d0: 0x0008, 0x32d1: 0x0008, - 0x32d2: 0x0008, 0x32d3: 0x0008, 0x32d4: 0x0008, 0x32d5: 0x0008, 0x32d6: 0x0008, 0x32d7: 0x0008, - 0x32d8: 0x0008, 0x32d9: 0x0008, 0x32da: 0x0008, 0x32db: 0x0008, 0x32dc: 0x0008, 0x32dd: 0x0008, - 0x32de: 0x0008, 0x32df: 0x0008, 0x32e0: 0x0008, 0x32e1: 0x0008, 0x32e2: 0x0008, 0x32e3: 0x0008, - 0x32e4: 0x0008, 0x32e5: 0x0008, 0x32e6: 0x0008, 0x32e7: 0x0008, 0x32e8: 0x0008, 0x32e9: 0x0008, - 0x32ea: 0x0008, 0x32eb: 0x0008, 0x32ec: 0x0008, 0x32ed: 0x0008, 0x32ee: 0x0008, 0x32ef: 0x0008, - 0x32f0: 0x0008, 0x32f1: 0x0008, 0x32f2: 0x0008, 0x32f3: 0x0008, 0x32f4: 0x0008, 0x32f5: 0x0008, - 0x32f6: 0x0008, 0x32f7: 0x0008, 0x32f8: 0x0008, 0x32f9: 0x0008, 0x32fa: 0x0008, 0x32fb: 0x0008, - 0x32fc: 0x0008, 0x32fd: 0x0008, 0x32fe: 0x0008, 0x32ff: 0x0008, + 0x32d0: 0x0024, 0x32d1: 0x0024, + 0x32d2: 0x0024, 0x32d3: 0x0024, 0x32d4: 0x0024, 0x32d5: 0x0024, 0x32d6: 0x0024, // Block 0xcc, offset 0x3300 - 0x3300: 0x0008, 0x3301: 0x0008, 0x3302: 0x0008, 0x3303: 0x0008, 0x3304: 0x0008, 0x3305: 0x0008, - 0x3306: 0x0008, 0x3307: 0x0008, 0x3308: 0x0008, 0x3309: 0x0008, 0x330a: 0x0008, 0x330b: 0x0008, - 0x330c: 0x0008, 0x330d: 0x0008, 0x330e: 0x0008, 0x330f: 0x0008, + 0x3304: 0x0024, 0x3305: 0x0024, + 0x3306: 0x0024, 0x3307: 0x0024, 0x3308: 0x0024, 0x3309: 0x0024, 0x330a: 0x0024, // Block 0xcd, offset 0x3340 - 0x3374: 0x0008, 0x3375: 0x0008, - 0x3376: 0x0008, 0x3377: 0x0008, 0x3378: 0x0008, 0x3379: 0x0008, 0x337a: 0x0008, 0x337b: 0x0008, - 0x337c: 0x0008, 0x337d: 0x0008, 0x337e: 0x0008, 0x337f: 0x0008, + 0x3344: 0x0008, + 0x336c: 0x0008, 0x336d: 0x0008, 0x336e: 0x0008, 0x336f: 0x0008, // Block 0xce, offset 0x3380 - 0x3395: 0x0008, 0x3396: 0x0008, 0x3397: 0x0008, + 0x3394: 0x0008, 0x3395: 0x0008, 0x3396: 0x0008, 0x3397: 0x0008, 0x3398: 0x0008, 0x3399: 0x0008, 0x339a: 0x0008, 0x339b: 0x0008, 0x339c: 0x0008, 0x339d: 0x0008, - 0x339e: 0x0008, 0x339f: 0x0008, 0x33a0: 0x0008, 0x33a1: 0x0008, 0x33a2: 0x0008, 0x33a3: 0x0008, - 0x33a4: 0x0008, 0x33a5: 0x0008, 0x33a6: 0x0008, 0x33a7: 0x0008, 0x33a8: 0x0008, 0x33a9: 0x0008, - 0x33aa: 0x0008, 0x33ab: 0x0008, 0x33ac: 0x0008, 0x33ad: 0x0008, 0x33ae: 0x0008, 0x33af: 0x0008, - 0x33b0: 0x0008, 0x33b1: 0x0008, 0x33b2: 0x0008, 0x33b3: 0x0008, 0x33b4: 0x0008, 0x33b5: 0x0008, - 0x33b6: 0x0008, 0x33b7: 0x0008, 0x33b8: 0x0008, 0x33b9: 0x0008, 0x33ba: 0x0008, 0x33bb: 0x0008, - 0x33bc: 0x0008, 0x33bd: 0x0008, 0x33be: 0x0008, 0x33bf: 0x0008, + 0x339e: 0x0008, 0x339f: 0x0008, + 0x33af: 0x0008, + 0x33b0: 0x0008, // Block 0xcf, offset 0x33c0 - 0x33cc: 0x0008, 0x33cd: 0x0008, 0x33ce: 0x0008, 0x33cf: 0x0008, + 0x33c0: 0x0008, + 0x33cf: 0x0008, 0x33d0: 0x0008, + 0x33f6: 0x0008, 0x33f7: 0x0008, 0x33f8: 0x0008, 0x33f9: 0x0008, 0x33fa: 0x0008, 0x33fb: 0x0008, + 0x33fc: 0x0008, 0x33fd: 0x0008, 0x33fe: 0x0008, 0x33ff: 0x0008, // Block 0xd0, offset 0x3400 - 0x3408: 0x0008, 0x3409: 0x0008, 0x340a: 0x0008, 0x340b: 0x0008, - 0x340c: 0x0008, 0x340d: 0x0008, 0x340e: 0x0008, 0x340f: 0x0008, - 0x341a: 0x0008, 0x341b: 0x0008, 0x341c: 0x0008, 0x341d: 0x0008, - 0x341e: 0x0008, 0x341f: 0x0008, + 0x3430: 0x0008, 0x3431: 0x0008, + 0x343e: 0x0008, 0x343f: 0x0008, // Block 0xd1, offset 0x3440 - 0x3448: 0x0008, 0x3449: 0x0008, 0x344a: 0x0008, 0x344b: 0x0008, - 0x344c: 0x0008, 0x344d: 0x0008, 0x344e: 0x0008, 0x344f: 0x0008, + 0x344e: 0x0008, 0x3451: 0x0008, + 0x3452: 0x0008, 0x3453: 0x0008, 0x3454: 0x0008, 0x3455: 0x0008, 0x3456: 0x0008, 0x3457: 0x0008, + 0x3458: 0x0008, 0x3459: 0x0008, 0x345a: 0x0008, 0x346e: 0x0008, 0x346f: 0x0008, 0x3470: 0x0008, 0x3471: 0x0008, 0x3472: 0x0008, 0x3473: 0x0008, 0x3474: 0x0008, 0x3475: 0x0008, 0x3476: 0x0008, 0x3477: 0x0008, 0x3478: 0x0008, 0x3479: 0x0008, 0x347a: 0x0008, 0x347b: 0x0008, 0x347c: 0x0008, 0x347d: 0x0008, 0x347e: 0x0008, 0x347f: 0x0008, // Block 0xd2, offset 0x3480 + 0x3480: 0x0008, 0x3481: 0x0008, 0x3482: 0x0008, 0x3483: 0x0008, 0x3484: 0x0008, 0x3485: 0x0008, + 0x3486: 0x0008, 0x3487: 0x0008, 0x3488: 0x0008, 0x3489: 0x0008, 0x348a: 0x0008, 0x348b: 0x0008, 0x348c: 0x0008, 0x348d: 0x0008, 0x348e: 0x0008, 0x348f: 0x0008, 0x3490: 0x0008, 0x3491: 0x0008, 0x3492: 0x0008, 0x3493: 0x0008, 0x3494: 0x0008, 0x3495: 0x0008, 0x3496: 0x0008, 0x3497: 0x0008, 0x3498: 0x0008, 0x3499: 0x0008, 0x349a: 0x0008, 0x349b: 0x0008, 0x349c: 0x0008, 0x349d: 0x0008, 0x349e: 0x0008, 0x349f: 0x0008, 0x34a0: 0x0008, 0x34a1: 0x0008, 0x34a2: 0x0008, 0x34a3: 0x0008, - 0x34a4: 0x0008, 0x34a5: 0x0008, 0x34a6: 0x0008, 0x34a7: 0x0008, 0x34a8: 0x0008, 0x34a9: 0x0008, - 0x34aa: 0x0008, 0x34ab: 0x0008, 0x34ac: 0x0008, 0x34ad: 0x0008, 0x34ae: 0x0008, 0x34af: 0x0008, - 0x34b0: 0x0008, 0x34b1: 0x0008, 0x34b2: 0x0008, 0x34b3: 0x0008, 0x34b4: 0x0008, 0x34b5: 0x0008, - 0x34b6: 0x0008, 0x34b7: 0x0008, 0x34b8: 0x0008, 0x34b9: 0x0008, 0x34ba: 0x0008, - 0x34bc: 0x0008, 0x34bd: 0x0008, 0x34be: 0x0008, 0x34bf: 0x0008, + 0x34a4: 0x0008, 0x34a5: 0x0008, 0x34a6: 0x1000, 0x34a7: 0x1000, 0x34a8: 0x1000, 0x34a9: 0x1000, + 0x34aa: 0x1000, 0x34ab: 0x1000, 0x34ac: 0x1000, 0x34ad: 0x1000, 0x34ae: 0x1000, 0x34af: 0x1000, + 0x34b0: 0x1000, 0x34b1: 0x1000, 0x34b2: 0x1000, 0x34b3: 0x1000, 0x34b4: 0x1000, 0x34b5: 0x1000, + 0x34b6: 0x1000, 0x34b7: 0x1000, 0x34b8: 0x1000, 0x34b9: 0x1000, 0x34ba: 0x1000, 0x34bb: 0x1000, + 0x34bc: 0x1000, 0x34bd: 0x1000, 0x34be: 0x1000, 0x34bf: 0x1000, // Block 0xd3, offset 0x34c0 - 0x34c0: 0x0008, 0x34c1: 0x0008, 0x34c2: 0x0008, 0x34c3: 0x0008, 0x34c4: 0x0008, 0x34c5: 0x0008, - 0x34c7: 0x0008, 0x34c8: 0x0008, 0x34c9: 0x0008, 0x34ca: 0x0008, 0x34cb: 0x0008, - 0x34cc: 0x0008, 0x34cd: 0x0008, 0x34ce: 0x0008, 0x34cf: 0x0008, 0x34d0: 0x0008, 0x34d1: 0x0008, - 0x34d2: 0x0008, 0x34d3: 0x0008, 0x34d4: 0x0008, 0x34d5: 0x0008, 0x34d6: 0x0008, 0x34d7: 0x0008, - 0x34d8: 0x0008, 0x34d9: 0x0008, 0x34da: 0x0008, 0x34db: 0x0008, 0x34dc: 0x0008, 0x34dd: 0x0008, - 0x34de: 0x0008, 0x34df: 0x0008, 0x34e0: 0x0008, 0x34e1: 0x0008, 0x34e2: 0x0008, 0x34e3: 0x0008, - 0x34e4: 0x0008, 0x34e5: 0x0008, 0x34e6: 0x0008, 0x34e7: 0x0008, 0x34e8: 0x0008, 0x34e9: 0x0008, - 0x34ea: 0x0008, 0x34eb: 0x0008, 0x34ec: 0x0008, 0x34ed: 0x0008, 0x34ee: 0x0008, 0x34ef: 0x0008, - 0x34f0: 0x0008, 0x34f1: 0x0008, 0x34f2: 0x0008, 0x34f3: 0x0008, 0x34f4: 0x0008, 0x34f5: 0x0008, - 0x34f6: 0x0008, 0x34f7: 0x0008, 0x34f8: 0x0008, 0x34f9: 0x0008, 0x34fa: 0x0008, 0x34fb: 0x0008, + 0x34c1: 0x0008, 0x34c2: 0x0008, 0x34c3: 0x0008, 0x34c4: 0x0008, 0x34c5: 0x0008, + 0x34c6: 0x0008, 0x34c7: 0x0008, 0x34c8: 0x0008, 0x34c9: 0x0008, 0x34ca: 0x0008, 0x34cb: 0x0008, + 0x34cc: 0x0008, 0x34cd: 0x0008, 0x34ce: 0x0008, 0x34cf: 0x0008, + 0x34da: 0x0008, + 0x34ef: 0x0008, + 0x34f2: 0x0008, 0x34f3: 0x0008, 0x34f4: 0x0008, 0x34f5: 0x0008, + 0x34f6: 0x0008, 0x34f7: 0x0008, 0x34f8: 0x0008, 0x34f9: 0x0008, 0x34fa: 0x0008, 0x34fc: 0x0008, 0x34fd: 0x0008, 0x34fe: 0x0008, 0x34ff: 0x0008, // Block 0xd4, offset 0x3500 - 0x3500: 0x0002, 0x3501: 0x0002, 0x3502: 0x0002, 0x3503: 0x0002, 0x3504: 0x0002, 0x3505: 0x0002, - 0x3506: 0x0002, 0x3507: 0x0002, 0x3508: 0x0002, 0x3509: 0x0002, 0x350a: 0x0002, 0x350b: 0x0002, - 0x350c: 0x0002, 0x350d: 0x0002, 0x350e: 0x0002, 0x350f: 0x0002, 0x3510: 0x0002, 0x3511: 0x0002, - 0x3512: 0x0002, 0x3513: 0x0002, 0x3514: 0x0002, 0x3515: 0x0002, 0x3516: 0x0002, 0x3517: 0x0002, - 0x3518: 0x0002, 0x3519: 0x0002, 0x351a: 0x0002, 0x351b: 0x0002, 0x351c: 0x0002, 0x351d: 0x0002, - 0x351e: 0x0002, 0x351f: 0x0002, 0x3520: 0x0004, 0x3521: 0x0004, 0x3522: 0x0004, 0x3523: 0x0004, - 0x3524: 0x0004, 0x3525: 0x0004, 0x3526: 0x0004, 0x3527: 0x0004, 0x3528: 0x0004, 0x3529: 0x0004, - 0x352a: 0x0004, 0x352b: 0x0004, 0x352c: 0x0004, 0x352d: 0x0004, 0x352e: 0x0004, 0x352f: 0x0004, - 0x3530: 0x0004, 0x3531: 0x0004, 0x3532: 0x0004, 0x3533: 0x0004, 0x3534: 0x0004, 0x3535: 0x0004, - 0x3536: 0x0004, 0x3537: 0x0004, 0x3538: 0x0004, 0x3539: 0x0004, 0x353a: 0x0004, 0x353b: 0x0004, - 0x353c: 0x0004, 0x353d: 0x0004, 0x353e: 0x0004, 0x353f: 0x0004, + 0x3509: 0x0008, 0x350a: 0x0008, 0x350b: 0x0008, + 0x350c: 0x0008, 0x350d: 0x0008, 0x350e: 0x0008, 0x350f: 0x0008, 0x3510: 0x0008, 0x3511: 0x0008, + 0x3512: 0x0008, 0x3513: 0x0008, 0x3514: 0x0008, 0x3515: 0x0008, 0x3516: 0x0008, 0x3517: 0x0008, + 0x3518: 0x0008, 0x3519: 0x0008, 0x351a: 0x0008, 0x351b: 0x0008, 0x351c: 0x0008, 0x351d: 0x0008, + 0x351e: 0x0008, 0x351f: 0x0008, + 0x3526: 0x0008, 0x3527: 0x0008, 0x3528: 0x0008, 0x3529: 0x0008, + 0x352a: 0x0008, 0x352b: 0x0008, 0x352c: 0x0008, 0x352d: 0x0008, 0x352e: 0x0008, 0x352f: 0x0008, + 0x3530: 0x0008, 0x3531: 0x0008, 0x3532: 0x0008, 0x3533: 0x0008, 0x3534: 0x0008, 0x3535: 0x0008, + 0x3536: 0x0008, 0x3537: 0x0008, 0x3538: 0x0008, 0x3539: 0x0008, 0x353a: 0x0008, 0x353b: 0x0008, + 0x353c: 0x0008, 0x353d: 0x0008, 0x353e: 0x0008, 0x353f: 0x0008, // Block 0xd5, offset 0x3540 - 0x3540: 0x0002, 0x3541: 0x0002, 0x3542: 0x0002, 0x3543: 0x0002, 0x3544: 0x0002, 0x3545: 0x0002, - 0x3546: 0x0002, 0x3547: 0x0002, 0x3548: 0x0002, 0x3549: 0x0002, 0x354a: 0x0002, 0x354b: 0x0002, - 0x354c: 0x0002, 0x354d: 0x0002, 0x354e: 0x0002, 0x354f: 0x0002, 0x3550: 0x0002, 0x3551: 0x0002, - 0x3552: 0x0002, 0x3553: 0x0002, 0x3554: 0x0002, 0x3555: 0x0002, 0x3556: 0x0002, 0x3557: 0x0002, - 0x3558: 0x0002, 0x3559: 0x0002, 0x355a: 0x0002, 0x355b: 0x0002, 0x355c: 0x0002, 0x355d: 0x0002, - 0x355e: 0x0002, 0x355f: 0x0002, 0x3560: 0x0002, 0x3561: 0x0002, 0x3562: 0x0002, 0x3563: 0x0002, - 0x3564: 0x0002, 0x3565: 0x0002, 0x3566: 0x0002, 0x3567: 0x0002, 0x3568: 0x0002, 0x3569: 0x0002, - 0x356a: 0x0002, 0x356b: 0x0002, 0x356c: 0x0002, 0x356d: 0x0002, 0x356e: 0x0002, 0x356f: 0x0002, - 0x3570: 0x0002, 0x3571: 0x0002, 0x3572: 0x0002, 0x3573: 0x0002, 0x3574: 0x0002, 0x3575: 0x0002, - 0x3576: 0x0002, 0x3577: 0x0002, 0x3578: 0x0002, 0x3579: 0x0002, 0x357a: 0x0002, 0x357b: 0x0002, - 0x357c: 0x0002, 0x357d: 0x0002, 0x357e: 0x0002, 0x357f: 0x0002, + 0x3540: 0x0008, 0x3541: 0x0008, 0x3542: 0x0008, 0x3543: 0x0008, 0x3544: 0x0008, 0x3545: 0x0008, + 0x3546: 0x0008, 0x3547: 0x0008, 0x3548: 0x0008, 0x3549: 0x0008, 0x354a: 0x0008, 0x354b: 0x0008, + 0x354c: 0x0008, 0x354d: 0x0008, 0x354e: 0x0008, 0x354f: 0x0008, 0x3550: 0x0008, 0x3551: 0x0008, + 0x3552: 0x0008, 0x3553: 0x0008, 0x3554: 0x0008, 0x3555: 0x0008, 0x3556: 0x0008, 0x3557: 0x0008, + 0x3558: 0x0008, 0x3559: 0x0008, 0x355a: 0x0008, 0x355b: 0x0008, 0x355c: 0x0008, 0x355d: 0x0008, + 0x355e: 0x0008, 0x355f: 0x0008, 0x3560: 0x0008, 0x3561: 0x0008, 0x3562: 0x0008, 0x3563: 0x0008, + 0x3564: 0x0008, 0x3565: 0x0008, 0x3566: 0x0008, 0x3567: 0x0008, 0x3568: 0x0008, 0x3569: 0x0008, + 0x356a: 0x0008, 0x356b: 0x0008, 0x356c: 0x0008, 0x356d: 0x0008, 0x356e: 0x0008, 0x356f: 0x0008, + 0x3570: 0x0008, 0x3571: 0x0008, 0x3572: 0x0008, 0x3573: 0x0008, 0x3574: 0x0008, 0x3575: 0x0008, + 0x3576: 0x0008, 0x3577: 0x0008, 0x3578: 0x0008, 0x3579: 0x0008, 0x357a: 0x0008, 0x357b: 0x0008, + 0x357c: 0x0008, 0x357d: 0x0008, 0x357e: 0x0008, 0x357f: 0x0008, // Block 0xd6, offset 0x3580 - 0x3580: 0x0004, 0x3581: 0x0004, 0x3582: 0x0004, 0x3583: 0x0004, 0x3584: 0x0004, 0x3585: 0x0004, - 0x3586: 0x0004, 0x3587: 0x0004, 0x3588: 0x0004, 0x3589: 0x0004, 0x358a: 0x0004, 0x358b: 0x0004, - 0x358c: 0x0004, 0x358d: 0x0004, 0x358e: 0x0004, 0x358f: 0x0004, 0x3590: 0x0004, 0x3591: 0x0004, - 0x3592: 0x0004, 0x3593: 0x0004, 0x3594: 0x0004, 0x3595: 0x0004, 0x3596: 0x0004, 0x3597: 0x0004, - 0x3598: 0x0004, 0x3599: 0x0004, 0x359a: 0x0004, 0x359b: 0x0004, 0x359c: 0x0004, 0x359d: 0x0004, - 0x359e: 0x0004, 0x359f: 0x0004, 0x35a0: 0x0004, 0x35a1: 0x0004, 0x35a2: 0x0004, 0x35a3: 0x0004, - 0x35a4: 0x0004, 0x35a5: 0x0004, 0x35a6: 0x0004, 0x35a7: 0x0004, 0x35a8: 0x0004, 0x35a9: 0x0004, - 0x35aa: 0x0004, 0x35ab: 0x0004, 0x35ac: 0x0004, 0x35ad: 0x0004, 0x35ae: 0x0004, 0x35af: 0x0004, - 0x35b0: 0x0002, 0x35b1: 0x0002, 0x35b2: 0x0002, 0x35b3: 0x0002, 0x35b4: 0x0002, 0x35b5: 0x0002, - 0x35b6: 0x0002, 0x35b7: 0x0002, 0x35b8: 0x0002, 0x35b9: 0x0002, 0x35ba: 0x0002, 0x35bb: 0x0002, - 0x35bc: 0x0002, 0x35bd: 0x0002, 0x35be: 0x0002, 0x35bf: 0x0002, + 0x3580: 0x0008, 0x3581: 0x0008, 0x3582: 0x0008, 0x3583: 0x0008, 0x3584: 0x0008, 0x3585: 0x0008, + 0x3586: 0x0008, 0x3587: 0x0008, 0x3588: 0x0008, 0x3589: 0x0008, 0x358a: 0x0008, 0x358b: 0x0008, + 0x358c: 0x0008, 0x358d: 0x0008, 0x358e: 0x0008, 0x358f: 0x0008, 0x3590: 0x0008, 0x3591: 0x0008, + 0x3592: 0x0008, 0x3593: 0x0008, 0x3594: 0x0008, 0x3595: 0x0008, 0x3596: 0x0008, 0x3597: 0x0008, + 0x3598: 0x0008, 0x3599: 0x0008, 0x359a: 0x0008, 0x359b: 0x0008, 0x359c: 0x0008, 0x359d: 0x0008, + 0x359e: 0x0008, 0x359f: 0x0008, 0x35a0: 0x0008, 0x35a1: 0x0008, + 0x35a4: 0x0008, 0x35a5: 0x0008, 0x35a6: 0x0008, 0x35a7: 0x0008, 0x35a8: 0x0008, 0x35a9: 0x0008, + 0x35aa: 0x0008, 0x35ab: 0x0008, 0x35ac: 0x0008, 0x35ad: 0x0008, 0x35ae: 0x0008, 0x35af: 0x0008, + 0x35b0: 0x0008, 0x35b1: 0x0008, 0x35b2: 0x0008, 0x35b3: 0x0008, 0x35b4: 0x0008, 0x35b5: 0x0008, + 0x35b6: 0x0008, 0x35b7: 0x0008, 0x35b8: 0x0008, 0x35b9: 0x0008, 0x35ba: 0x0008, 0x35bb: 0x0008, + 0x35bc: 0x0008, 0x35bd: 0x0008, 0x35be: 0x0008, 0x35bf: 0x0008, + // Block 0xd7, offset 0x35c0 + 0x35c0: 0x0008, 0x35c1: 0x0008, 0x35c2: 0x0008, 0x35c3: 0x0008, 0x35c4: 0x0008, 0x35c5: 0x0008, + 0x35c6: 0x0008, 0x35c7: 0x0008, 0x35c8: 0x0008, 0x35c9: 0x0008, 0x35ca: 0x0008, 0x35cb: 0x0008, + 0x35cc: 0x0008, 0x35cd: 0x0008, 0x35ce: 0x0008, 0x35cf: 0x0008, 0x35d0: 0x0008, 0x35d1: 0x0008, + 0x35d2: 0x0008, 0x35d3: 0x0008, 0x35d6: 0x0008, 0x35d7: 0x0008, + 0x35d9: 0x0008, 0x35da: 0x0008, 0x35db: 0x0008, + 0x35de: 0x0008, 0x35df: 0x0008, 0x35e0: 0x0008, 0x35e1: 0x0008, 0x35e2: 0x0008, 0x35e3: 0x0008, + 0x35e4: 0x0008, 0x35e5: 0x0008, 0x35e6: 0x0008, 0x35e7: 0x0008, 0x35e8: 0x0008, 0x35e9: 0x0008, + 0x35ea: 0x0008, 0x35eb: 0x0008, 0x35ec: 0x0008, 0x35ed: 0x0008, 0x35ee: 0x0008, 0x35ef: 0x0008, + 0x35f0: 0x0008, 0x35f1: 0x0008, 0x35f2: 0x0008, 0x35f3: 0x0008, 0x35f4: 0x0008, 0x35f5: 0x0008, + 0x35f6: 0x0008, 0x35f7: 0x0008, 0x35f8: 0x0008, 0x35f9: 0x0008, 0x35fa: 0x0008, 0x35fb: 0x0008, + 0x35fc: 0x0008, 0x35fd: 0x0008, 0x35fe: 0x0008, 0x35ff: 0x0008, + // Block 0xd8, offset 0x3600 + 0x3600: 0x0008, 0x3601: 0x0008, 0x3602: 0x0008, 0x3603: 0x0008, 0x3604: 0x0008, 0x3605: 0x0008, + 0x3606: 0x0008, 0x3607: 0x0008, 0x3608: 0x0008, 0x3609: 0x0008, 0x360a: 0x0008, 0x360b: 0x0008, + 0x360c: 0x0008, 0x360d: 0x0008, 0x360e: 0x0008, 0x360f: 0x0008, 0x3610: 0x0008, 0x3611: 0x0008, + 0x3612: 0x0008, 0x3613: 0x0008, 0x3614: 0x0008, 0x3615: 0x0008, 0x3616: 0x0008, 0x3617: 0x0008, + 0x3618: 0x0008, 0x3619: 0x0008, 0x361a: 0x0008, 0x361b: 0x0008, 0x361c: 0x0008, 0x361d: 0x0008, + 0x361e: 0x0008, 0x361f: 0x0008, 0x3620: 0x0008, 0x3621: 0x0008, 0x3622: 0x0008, 0x3623: 0x0008, + 0x3624: 0x0008, 0x3625: 0x0008, 0x3626: 0x0008, 0x3627: 0x0008, 0x3628: 0x0008, 0x3629: 0x0008, + 0x362a: 0x0008, 0x362b: 0x0008, 0x362c: 0x0008, 0x362d: 0x0008, 0x362e: 0x0008, 0x362f: 0x0008, + 0x3630: 0x0008, 0x3633: 0x0008, 0x3634: 0x0008, 0x3635: 0x0008, + 0x3637: 0x0008, 0x3638: 0x0008, 0x3639: 0x0008, 0x363a: 0x0008, 0x363b: 0x0024, + 0x363c: 0x0024, 0x363d: 0x0024, 0x363e: 0x0024, 0x363f: 0x0024, + // Block 0xd9, offset 0x3640 + 0x3640: 0x0008, 0x3641: 0x0008, 0x3642: 0x0008, 0x3643: 0x0008, 0x3644: 0x0008, 0x3645: 0x0008, + 0x3646: 0x0008, 0x3647: 0x0008, 0x3648: 0x0008, 0x3649: 0x0008, 0x364a: 0x0008, 0x364b: 0x0008, + 0x364c: 0x0008, 0x364d: 0x0008, 0x364e: 0x0008, 0x364f: 0x0008, 0x3650: 0x0008, 0x3651: 0x0008, + 0x3652: 0x0008, 0x3653: 0x0008, 0x3654: 0x0008, 0x3655: 0x0008, 0x3656: 0x0008, 0x3657: 0x0008, + 0x3658: 0x0008, 0x3659: 0x0008, 0x365a: 0x0008, 0x365b: 0x0008, 0x365c: 0x0008, 0x365d: 0x0008, + 0x365e: 0x0008, 0x365f: 0x0008, 0x3660: 0x0008, 0x3661: 0x0008, 0x3662: 0x0008, 0x3663: 0x0008, + 0x3664: 0x0008, 0x3665: 0x0008, 0x3666: 0x0008, 0x3667: 0x0008, 0x3668: 0x0008, 0x3669: 0x0008, + 0x366a: 0x0008, 0x366b: 0x0008, 0x366c: 0x0008, 0x366d: 0x0008, 0x366e: 0x0008, 0x366f: 0x0008, + 0x3670: 0x0008, 0x3671: 0x0008, 0x3672: 0x0008, 0x3673: 0x0008, 0x3674: 0x0008, 0x3675: 0x0008, + 0x3676: 0x0008, 0x3677: 0x0008, 0x3678: 0x0008, 0x3679: 0x0008, 0x367a: 0x0008, 0x367b: 0x0008, + 0x367c: 0x0008, 0x367d: 0x0008, 0x367f: 0x0008, + // Block 0xda, offset 0x3680 + 0x3680: 0x0008, 0x3681: 0x0008, 0x3682: 0x0008, 0x3683: 0x0008, 0x3684: 0x0008, 0x3685: 0x0008, + 0x3686: 0x0008, 0x3687: 0x0008, 0x3688: 0x0008, 0x3689: 0x0008, 0x368a: 0x0008, 0x368b: 0x0008, + 0x368c: 0x0008, 0x368d: 0x0008, 0x368e: 0x0008, 0x368f: 0x0008, 0x3690: 0x0008, 0x3691: 0x0008, + 0x3692: 0x0008, 0x3693: 0x0008, 0x3694: 0x0008, 0x3695: 0x0008, 0x3696: 0x0008, 0x3697: 0x0008, + 0x3698: 0x0008, 0x3699: 0x0008, 0x369a: 0x0008, 0x369b: 0x0008, 0x369c: 0x0008, 0x369d: 0x0008, + 0x369e: 0x0008, 0x369f: 0x0008, 0x36a0: 0x0008, 0x36a1: 0x0008, 0x36a2: 0x0008, 0x36a3: 0x0008, + 0x36a4: 0x0008, 0x36a5: 0x0008, 0x36a6: 0x0008, 0x36a7: 0x0008, 0x36a8: 0x0008, 0x36a9: 0x0008, + 0x36aa: 0x0008, 0x36ab: 0x0008, 0x36ac: 0x0008, 0x36ad: 0x0008, 0x36ae: 0x0008, 0x36af: 0x0008, + 0x36b0: 0x0008, 0x36b1: 0x0008, 0x36b2: 0x0008, 0x36b3: 0x0008, 0x36b4: 0x0008, 0x36b5: 0x0008, + 0x36b6: 0x0008, 0x36b7: 0x0008, 0x36b8: 0x0008, 0x36b9: 0x0008, 0x36ba: 0x0008, 0x36bb: 0x0008, + 0x36bc: 0x0008, 0x36bd: 0x0008, + // Block 0xdb, offset 0x36c0 + 0x36c9: 0x0008, 0x36ca: 0x0008, 0x36cb: 0x0008, + 0x36cc: 0x0008, 0x36cd: 0x0008, 0x36ce: 0x0008, 0x36d0: 0x0008, 0x36d1: 0x0008, + 0x36d2: 0x0008, 0x36d3: 0x0008, 0x36d4: 0x0008, 0x36d5: 0x0008, 0x36d6: 0x0008, 0x36d7: 0x0008, + 0x36d8: 0x0008, 0x36d9: 0x0008, 0x36da: 0x0008, 0x36db: 0x0008, 0x36dc: 0x0008, 0x36dd: 0x0008, + 0x36de: 0x0008, 0x36df: 0x0008, 0x36e0: 0x0008, 0x36e1: 0x0008, 0x36e2: 0x0008, 0x36e3: 0x0008, + 0x36e4: 0x0008, 0x36e5: 0x0008, 0x36e6: 0x0008, 0x36e7: 0x0008, + 0x36ef: 0x0008, + 0x36f0: 0x0008, 0x36f3: 0x0008, 0x36f4: 0x0008, 0x36f5: 0x0008, + 0x36f6: 0x0008, 0x36f7: 0x0008, 0x36f8: 0x0008, 0x36f9: 0x0008, 0x36fa: 0x0008, + // Block 0xdc, offset 0x3700 + 0x3707: 0x0008, 0x370a: 0x0008, 0x370b: 0x0008, + 0x370c: 0x0008, 0x370d: 0x0008, 0x3710: 0x0008, + 0x3715: 0x0008, 0x3716: 0x0008, + 0x3724: 0x0008, 0x3725: 0x0008, 0x3728: 0x0008, + 0x3731: 0x0008, 0x3732: 0x0008, + 0x373c: 0x0008, + // Block 0xdd, offset 0x3740 + 0x3742: 0x0008, 0x3743: 0x0008, 0x3744: 0x0008, + 0x3751: 0x0008, + 0x3752: 0x0008, 0x3753: 0x0008, + 0x375c: 0x0008, 0x375d: 0x0008, + 0x375e: 0x0008, 0x3761: 0x0008, 0x3763: 0x0008, + 0x3768: 0x0008, + 0x376f: 0x0008, + 0x3773: 0x0008, + 0x377a: 0x0008, 0x377b: 0x0008, + 0x377c: 0x0008, 0x377d: 0x0008, 0x377e: 0x0008, 0x377f: 0x0008, + // Block 0xde, offset 0x3780 + 0x3780: 0x0008, 0x3781: 0x0008, 0x3782: 0x0008, 0x3783: 0x0008, 0x3784: 0x0008, 0x3785: 0x0008, + 0x3786: 0x0008, 0x3787: 0x0008, 0x3788: 0x0008, 0x3789: 0x0008, 0x378a: 0x0008, 0x378b: 0x0008, + 0x378c: 0x0008, 0x378d: 0x0008, 0x378e: 0x0008, 0x378f: 0x0008, + // Block 0xdf, offset 0x37c0 + 0x37c0: 0x0008, 0x37c1: 0x0008, 0x37c2: 0x0008, 0x37c3: 0x0008, 0x37c4: 0x0008, 0x37c5: 0x0008, + 0x37cb: 0x0008, + 0x37cc: 0x0008, 0x37cd: 0x0008, 0x37ce: 0x0008, 0x37cf: 0x0008, 0x37d0: 0x0008, 0x37d1: 0x0008, + 0x37d2: 0x0008, 0x37d5: 0x0008, 0x37d6: 0x0008, 0x37d7: 0x0008, + 0x37d8: 0x0008, 0x37d9: 0x0008, 0x37da: 0x0008, 0x37db: 0x0008, 0x37dc: 0x0008, 0x37dd: 0x0008, + 0x37de: 0x0008, 0x37df: 0x0008, 0x37e0: 0x0008, 0x37e1: 0x0008, 0x37e2: 0x0008, 0x37e3: 0x0008, + 0x37e4: 0x0008, 0x37e5: 0x0008, 0x37e9: 0x0008, + 0x37eb: 0x0008, 0x37ec: 0x0008, 0x37ed: 0x0008, 0x37ee: 0x0008, 0x37ef: 0x0008, + 0x37f0: 0x0008, 0x37f3: 0x0008, 0x37f4: 0x0008, 0x37f5: 0x0008, + 0x37f6: 0x0008, 0x37f7: 0x0008, 0x37f8: 0x0008, 0x37f9: 0x0008, 0x37fa: 0x0008, 0x37fb: 0x0008, + 0x37fc: 0x0008, 0x37fd: 0x0008, 0x37fe: 0x0008, 0x37ff: 0x0008, + // Block 0xe0, offset 0x3800 + 0x381a: 0x0008, 0x381b: 0x0008, 0x381c: 0x0008, 0x381d: 0x0008, + 0x381e: 0x0008, 0x381f: 0x0008, 0x3820: 0x0008, 0x3821: 0x0008, 0x3822: 0x0008, 0x3823: 0x0008, + 0x3824: 0x0008, 0x3825: 0x0008, 0x3826: 0x0008, 0x3827: 0x0008, 0x3828: 0x0008, 0x3829: 0x0008, + 0x382a: 0x0008, 0x382b: 0x0008, 0x382c: 0x0008, 0x382d: 0x0008, 0x382e: 0x0008, 0x382f: 0x0008, + 0x3830: 0x0008, 0x3831: 0x0008, 0x3832: 0x0008, 0x3833: 0x0008, 0x3834: 0x0008, 0x3835: 0x0008, + 0x3836: 0x0008, 0x3837: 0x0008, 0x3838: 0x0008, 0x3839: 0x0008, 0x383a: 0x0008, 0x383b: 0x0008, + 0x383c: 0x0008, 0x383d: 0x0008, 0x383e: 0x0008, 0x383f: 0x0008, + // Block 0xe1, offset 0x3840 + 0x384c: 0x0008, 0x384d: 0x0008, 0x384e: 0x0008, 0x384f: 0x0008, + // Block 0xe2, offset 0x3880 + 0x3888: 0x0008, 0x3889: 0x0008, 0x388a: 0x0008, 0x388b: 0x0008, + 0x388c: 0x0008, 0x388d: 0x0008, 0x388e: 0x0008, 0x388f: 0x0008, + 0x389a: 0x0008, 0x389b: 0x0008, 0x389c: 0x0008, 0x389d: 0x0008, + 0x389e: 0x0008, 0x389f: 0x0008, + // Block 0xe3, offset 0x38c0 + 0x38c8: 0x0008, 0x38c9: 0x0008, 0x38ca: 0x0008, 0x38cb: 0x0008, + 0x38cc: 0x0008, 0x38cd: 0x0008, 0x38ce: 0x0008, 0x38cf: 0x0008, + 0x38ee: 0x0008, 0x38ef: 0x0008, + 0x38fc: 0x0008, 0x38fd: 0x0008, 0x38fe: 0x0008, 0x38ff: 0x0008, + // Block 0xe4, offset 0x3900 + 0x3902: 0x0008, 0x3903: 0x0008, 0x3904: 0x0008, 0x3905: 0x0008, + 0x3906: 0x0008, 0x3907: 0x0008, 0x3908: 0x0008, 0x3909: 0x0008, 0x390a: 0x0008, 0x390b: 0x0008, + 0x390c: 0x0008, 0x390d: 0x0008, 0x390e: 0x0008, 0x390f: 0x0008, + 0x3919: 0x0008, 0x391a: 0x0008, 0x391b: 0x0008, 0x391c: 0x0008, 0x391d: 0x0008, + 0x391e: 0x0008, 0x391f: 0x0008, 0x3920: 0x0008, 0x3921: 0x0008, 0x3922: 0x0008, 0x3923: 0x0008, + 0x3924: 0x0008, 0x3925: 0x0008, 0x3926: 0x0008, 0x3927: 0x0008, 0x3928: 0x0008, 0x3929: 0x0008, + 0x392a: 0x0008, 0x392b: 0x0008, 0x392c: 0x0008, 0x392d: 0x0008, 0x392e: 0x0008, 0x392f: 0x0008, + 0x3930: 0x0008, 0x3931: 0x0008, 0x3932: 0x0008, 0x3933: 0x0008, 0x3934: 0x0008, 0x3935: 0x0008, + 0x3936: 0x0008, 0x3937: 0x0008, 0x3938: 0x0008, 0x3939: 0x0008, 0x393a: 0x0008, 0x393b: 0x0008, + 0x393c: 0x0008, 0x393d: 0x0008, 0x393e: 0x0008, 0x393f: 0x0008, + // Block 0xe5, offset 0x3940 + 0x394c: 0x0008, 0x394d: 0x0008, 0x394e: 0x0008, 0x394f: 0x0008, 0x3950: 0x0008, 0x3951: 0x0008, + 0x3952: 0x0008, 0x3953: 0x0008, 0x3954: 0x0008, 0x3955: 0x0008, 0x3956: 0x0008, 0x3957: 0x0008, + 0x3958: 0x0008, 0x3959: 0x0008, 0x395a: 0x0008, 0x395b: 0x0008, 0x395c: 0x0008, 0x395d: 0x0008, + 0x395e: 0x0008, 0x395f: 0x0008, 0x3960: 0x0008, 0x3961: 0x0008, 0x3962: 0x0008, 0x3963: 0x0008, + 0x3964: 0x0008, 0x3965: 0x0008, 0x3966: 0x0008, 0x3967: 0x0008, 0x3968: 0x0008, 0x3969: 0x0008, + 0x396a: 0x0008, 0x396b: 0x0008, 0x396c: 0x0008, 0x396d: 0x0008, 0x396e: 0x0008, 0x396f: 0x0008, + 0x3970: 0x0008, 0x3971: 0x0008, 0x3972: 0x0008, 0x3973: 0x0008, 0x3974: 0x0008, 0x3975: 0x0008, + 0x3976: 0x0008, 0x3977: 0x0008, 0x3978: 0x0008, 0x3979: 0x0008, 0x397a: 0x0008, + 0x397c: 0x0008, 0x397d: 0x0008, 0x397e: 0x0008, 0x397f: 0x0008, + // Block 0xe6, offset 0x3980 + 0x3980: 0x0008, 0x3981: 0x0008, 0x3982: 0x0008, 0x3983: 0x0008, 0x3984: 0x0008, 0x3985: 0x0008, + 0x3987: 0x0008, 0x3988: 0x0008, 0x3989: 0x0008, 0x398a: 0x0008, 0x398b: 0x0008, + 0x398c: 0x0008, 0x398d: 0x0008, 0x398e: 0x0008, 0x398f: 0x0008, 0x3990: 0x0008, 0x3991: 0x0008, + 0x3992: 0x0008, 0x3993: 0x0008, 0x3994: 0x0008, 0x3995: 0x0008, 0x3996: 0x0008, 0x3997: 0x0008, + 0x3998: 0x0008, 0x3999: 0x0008, 0x399a: 0x0008, 0x399b: 0x0008, 0x399c: 0x0008, 0x399d: 0x0008, + 0x399e: 0x0008, 0x399f: 0x0008, 0x39a0: 0x0008, 0x39a1: 0x0008, 0x39a2: 0x0008, 0x39a3: 0x0008, + 0x39a4: 0x0008, 0x39a5: 0x0008, 0x39a6: 0x0008, 0x39a7: 0x0008, 0x39a8: 0x0008, 0x39a9: 0x0008, + 0x39aa: 0x0008, 0x39ab: 0x0008, 0x39ac: 0x0008, 0x39ad: 0x0008, 0x39ae: 0x0008, 0x39af: 0x0008, + 0x39b0: 0x0008, 0x39b1: 0x0008, 0x39b2: 0x0008, 0x39b3: 0x0008, 0x39b4: 0x0008, 0x39b5: 0x0008, + 0x39b6: 0x0008, 0x39b7: 0x0008, 0x39b8: 0x0008, 0x39b9: 0x0008, 0x39ba: 0x0008, 0x39bb: 0x0008, + 0x39bc: 0x0008, 0x39bd: 0x0008, 0x39be: 0x0008, 0x39bf: 0x0008, + // Block 0xe7, offset 0x39c0 + 0x39d8: 0x0008, 0x39d9: 0x0008, 0x39da: 0x0008, 0x39db: 0x0008, 0x39dc: 0x0008, 0x39dd: 0x0008, + 0x39de: 0x0008, 0x39df: 0x0008, + 0x39ee: 0x0008, 0x39ef: 0x0008, + 0x39f0: 0x0008, 0x39f1: 0x0008, 0x39f2: 0x0008, 0x39f3: 0x0008, 0x39f4: 0x0008, 0x39f5: 0x0008, + 0x39f6: 0x0008, 0x39f7: 0x0008, 0x39f8: 0x0008, 0x39f9: 0x0008, 0x39fa: 0x0008, 0x39fb: 0x0008, + 0x39fc: 0x0008, 0x39fd: 0x0008, 0x39fe: 0x0008, 0x39ff: 0x0008, + // Block 0xe8, offset 0x3a00 + 0x3a00: 0x0002, 0x3a01: 0x0002, 0x3a02: 0x0002, 0x3a03: 0x0002, 0x3a04: 0x0002, 0x3a05: 0x0002, + 0x3a06: 0x0002, 0x3a07: 0x0002, 0x3a08: 0x0002, 0x3a09: 0x0002, 0x3a0a: 0x0002, 0x3a0b: 0x0002, + 0x3a0c: 0x0002, 0x3a0d: 0x0002, 0x3a0e: 0x0002, 0x3a0f: 0x0002, 0x3a10: 0x0002, 0x3a11: 0x0002, + 0x3a12: 0x0002, 0x3a13: 0x0002, 0x3a14: 0x0002, 0x3a15: 0x0002, 0x3a16: 0x0002, 0x3a17: 0x0002, + 0x3a18: 0x0002, 0x3a19: 0x0002, 0x3a1a: 0x0002, 0x3a1b: 0x0002, 0x3a1c: 0x0002, 0x3a1d: 0x0002, + 0x3a1e: 0x0002, 0x3a1f: 0x0002, 0x3a20: 0x0024, 0x3a21: 0x0024, 0x3a22: 0x0024, 0x3a23: 0x0024, + 0x3a24: 0x0024, 0x3a25: 0x0024, 0x3a26: 0x0024, 0x3a27: 0x0024, 0x3a28: 0x0024, 0x3a29: 0x0024, + 0x3a2a: 0x0024, 0x3a2b: 0x0024, 0x3a2c: 0x0024, 0x3a2d: 0x0024, 0x3a2e: 0x0024, 0x3a2f: 0x0024, + 0x3a30: 0x0024, 0x3a31: 0x0024, 0x3a32: 0x0024, 0x3a33: 0x0024, 0x3a34: 0x0024, 0x3a35: 0x0024, + 0x3a36: 0x0024, 0x3a37: 0x0024, 0x3a38: 0x0024, 0x3a39: 0x0024, 0x3a3a: 0x0024, 0x3a3b: 0x0024, + 0x3a3c: 0x0024, 0x3a3d: 0x0024, 0x3a3e: 0x0024, 0x3a3f: 0x0024, + // Block 0xe9, offset 0x3a40 + 0x3a40: 0x0002, 0x3a41: 0x0002, 0x3a42: 0x0002, 0x3a43: 0x0002, 0x3a44: 0x0002, 0x3a45: 0x0002, + 0x3a46: 0x0002, 0x3a47: 0x0002, 0x3a48: 0x0002, 0x3a49: 0x0002, 0x3a4a: 0x0002, 0x3a4b: 0x0002, + 0x3a4c: 0x0002, 0x3a4d: 0x0002, 0x3a4e: 0x0002, 0x3a4f: 0x0002, 0x3a50: 0x0002, 0x3a51: 0x0002, + 0x3a52: 0x0002, 0x3a53: 0x0002, 0x3a54: 0x0002, 0x3a55: 0x0002, 0x3a56: 0x0002, 0x3a57: 0x0002, + 0x3a58: 0x0002, 0x3a59: 0x0002, 0x3a5a: 0x0002, 0x3a5b: 0x0002, 0x3a5c: 0x0002, 0x3a5d: 0x0002, + 0x3a5e: 0x0002, 0x3a5f: 0x0002, 0x3a60: 0x0002, 0x3a61: 0x0002, 0x3a62: 0x0002, 0x3a63: 0x0002, + 0x3a64: 0x0002, 0x3a65: 0x0002, 0x3a66: 0x0002, 0x3a67: 0x0002, 0x3a68: 0x0002, 0x3a69: 0x0002, + 0x3a6a: 0x0002, 0x3a6b: 0x0002, 0x3a6c: 0x0002, 0x3a6d: 0x0002, 0x3a6e: 0x0002, 0x3a6f: 0x0002, + 0x3a70: 0x0002, 0x3a71: 0x0002, 0x3a72: 0x0002, 0x3a73: 0x0002, 0x3a74: 0x0002, 0x3a75: 0x0002, + 0x3a76: 0x0002, 0x3a77: 0x0002, 0x3a78: 0x0002, 0x3a79: 0x0002, 0x3a7a: 0x0002, 0x3a7b: 0x0002, + 0x3a7c: 0x0002, 0x3a7d: 0x0002, 0x3a7e: 0x0002, 0x3a7f: 0x0002, + // Block 0xea, offset 0x3a80 + 0x3a80: 0x0024, 0x3a81: 0x0024, 0x3a82: 0x0024, 0x3a83: 0x0024, 0x3a84: 0x0024, 0x3a85: 0x0024, + 0x3a86: 0x0024, 0x3a87: 0x0024, 0x3a88: 0x0024, 0x3a89: 0x0024, 0x3a8a: 0x0024, 0x3a8b: 0x0024, + 0x3a8c: 0x0024, 0x3a8d: 0x0024, 0x3a8e: 0x0024, 0x3a8f: 0x0024, 0x3a90: 0x0024, 0x3a91: 0x0024, + 0x3a92: 0x0024, 0x3a93: 0x0024, 0x3a94: 0x0024, 0x3a95: 0x0024, 0x3a96: 0x0024, 0x3a97: 0x0024, + 0x3a98: 0x0024, 0x3a99: 0x0024, 0x3a9a: 0x0024, 0x3a9b: 0x0024, 0x3a9c: 0x0024, 0x3a9d: 0x0024, + 0x3a9e: 0x0024, 0x3a9f: 0x0024, 0x3aa0: 0x0024, 0x3aa1: 0x0024, 0x3aa2: 0x0024, 0x3aa3: 0x0024, + 0x3aa4: 0x0024, 0x3aa5: 0x0024, 0x3aa6: 0x0024, 0x3aa7: 0x0024, 0x3aa8: 0x0024, 0x3aa9: 0x0024, + 0x3aaa: 0x0024, 0x3aab: 0x0024, 0x3aac: 0x0024, 0x3aad: 0x0024, 0x3aae: 0x0024, 0x3aaf: 0x0024, + 0x3ab0: 0x0002, 0x3ab1: 0x0002, 0x3ab2: 0x0002, 0x3ab3: 0x0002, 0x3ab4: 0x0002, 0x3ab5: 0x0002, + 0x3ab6: 0x0002, 0x3ab7: 0x0002, 0x3ab8: 0x0002, 0x3ab9: 0x0002, 0x3aba: 0x0002, 0x3abb: 0x0002, + 0x3abc: 0x0002, 0x3abd: 0x0002, 0x3abe: 0x0002, 0x3abf: 0x0002, } // graphemesIndex: 25 blocks, 1600 entries, 1600 bytes @@ -1297,113 +1602,116 @@ var graphemesIndex = [1600]property{ 0xf0: 0x14, 0xf3: 0x16, // Block 0x4, offset 0x100 0x120: 0x0e, 0x121: 0x0f, 0x122: 0x10, 0x123: 0x11, 0x124: 0x12, 0x125: 0x13, 0x126: 0x14, 0x127: 0x15, - 0x128: 0x16, 0x129: 0x17, 0x12a: 0x16, 0x12b: 0x18, 0x12c: 0x19, 0x12d: 0x1a, 0x12e: 0x1b, 0x12f: 0x1c, - 0x130: 0x1d, 0x131: 0x1e, 0x132: 0x1f, 0x133: 0x20, 0x134: 0x21, 0x135: 0x22, 0x136: 0x23, 0x137: 0x24, - 0x138: 0x25, 0x139: 0x26, 0x13a: 0x27, 0x13b: 0x28, 0x13c: 0x29, 0x13d: 0x2a, 0x13e: 0x2b, 0x13f: 0x2c, + 0x128: 0x16, 0x129: 0x17, 0x12a: 0x18, 0x12b: 0x19, 0x12c: 0x1a, 0x12d: 0x1b, 0x12e: 0x1c, 0x12f: 0x1d, + 0x130: 0x1e, 0x131: 0x1f, 0x132: 0x20, 0x133: 0x21, 0x134: 0x22, 0x135: 0x23, 0x136: 0x24, 0x137: 0x25, + 0x138: 0x26, 0x139: 0x27, 0x13a: 0x28, 0x13b: 0x29, 0x13c: 0x2a, 0x13d: 0x2b, 0x13e: 0x2c, 0x13f: 0x2d, // Block 0x5, offset 0x140 - 0x140: 0x2d, 0x141: 0x2e, 0x142: 0x2f, 0x144: 0x30, 0x145: 0x31, 0x146: 0x32, 0x147: 0x33, - 0x14d: 0x34, - 0x15c: 0x35, 0x15d: 0x36, 0x15e: 0x37, 0x15f: 0x38, - 0x160: 0x39, 0x162: 0x3a, 0x164: 0x3b, - 0x168: 0x3c, 0x169: 0x3d, 0x16a: 0x3e, 0x16b: 0x3f, 0x16c: 0x40, 0x16d: 0x41, 0x16e: 0x42, 0x16f: 0x43, - 0x170: 0x44, 0x173: 0x45, 0x177: 0x02, + 0x140: 0x2e, 0x141: 0x2f, 0x142: 0x30, 0x144: 0x31, 0x145: 0x32, 0x146: 0x33, 0x147: 0x34, + 0x14d: 0x35, + 0x15c: 0x36, 0x15d: 0x37, 0x15e: 0x38, 0x15f: 0x39, + 0x160: 0x3a, 0x162: 0x3b, 0x164: 0x3c, + 0x168: 0x3d, 0x169: 0x3e, 0x16a: 0x3f, 0x16b: 0x40, 0x16c: 0x41, 0x16d: 0x42, 0x16e: 0x43, 0x16f: 0x44, + 0x170: 0x45, 0x173: 0x46, 0x177: 0x02, // Block 0x6, offset 0x180 - 0x180: 0x46, 0x181: 0x47, 0x183: 0x48, 0x184: 0x49, 0x186: 0x4a, - 0x18c: 0x4b, 0x18e: 0x4c, 0x18f: 0x4d, + 0x180: 0x47, 0x181: 0x48, 0x183: 0x49, 0x184: 0x4a, 0x186: 0x4b, + 0x18c: 0x4c, 0x18f: 0x4d, 0x193: 0x4e, 0x196: 0x4f, 0x197: 0x50, - 0x198: 0x51, 0x199: 0x52, 0x19a: 0x53, 0x19b: 0x52, 0x19c: 0x54, 0x19d: 0x55, 0x19e: 0x56, - 0x1a4: 0x57, - 0x1ac: 0x58, 0x1ad: 0x59, - 0x1b3: 0x5a, 0x1b5: 0x5b, 0x1b7: 0x5c, + 0x198: 0x51, 0x199: 0x52, 0x19a: 0x53, 0x19b: 0x54, 0x19c: 0x55, 0x19d: 0x56, 0x19e: 0x57, + 0x1a4: 0x58, + 0x1ac: 0x59, 0x1ad: 0x5a, + 0x1b3: 0x5b, 0x1b5: 0x5c, 0x1b7: 0x5d, // Block 0x7, offset 0x1c0 - 0x1c0: 0x5d, 0x1c2: 0x5e, - 0x1ca: 0x5f, + 0x1c0: 0x5e, 0x1c2: 0x5f, + 0x1ca: 0x60, // Block 0x8, offset 0x200 - 0x219: 0x60, 0x21a: 0x61, 0x21b: 0x62, - 0x220: 0x63, 0x222: 0x64, 0x223: 0x65, 0x224: 0x66, 0x225: 0x67, 0x226: 0x68, 0x227: 0x69, - 0x228: 0x6a, 0x229: 0x6b, 0x22a: 0x6c, 0x22b: 0x6d, 0x22f: 0x6e, - 0x230: 0x6f, 0x231: 0x70, 0x232: 0x71, 0x233: 0x72, 0x234: 0x73, 0x235: 0x74, 0x236: 0x75, 0x237: 0x6f, - 0x238: 0x70, 0x239: 0x71, 0x23a: 0x72, 0x23b: 0x73, 0x23c: 0x74, 0x23d: 0x75, 0x23e: 0x6f, 0x23f: 0x70, + 0x219: 0x61, 0x21a: 0x62, 0x21b: 0x63, + 0x220: 0x64, 0x222: 0x65, 0x223: 0x66, 0x224: 0x67, 0x225: 0x68, 0x226: 0x69, 0x227: 0x6a, + 0x228: 0x6b, 0x229: 0x6c, 0x22a: 0x6d, 0x22b: 0x6e, 0x22f: 0x6f, + 0x230: 0x70, 0x231: 0x71, 0x232: 0x72, 0x233: 0x73, 0x234: 0x74, 0x235: 0x75, 0x236: 0x76, 0x237: 0x70, + 0x238: 0x71, 0x239: 0x72, 0x23a: 0x73, 0x23b: 0x74, 0x23c: 0x75, 0x23d: 0x76, 0x23e: 0x70, 0x23f: 0x71, // Block 0x9, offset 0x240 - 0x240: 0x71, 0x241: 0x72, 0x242: 0x73, 0x243: 0x74, 0x244: 0x75, 0x245: 0x6f, 0x246: 0x70, 0x247: 0x71, - 0x248: 0x72, 0x249: 0x73, 0x24a: 0x74, 0x24b: 0x75, 0x24c: 0x6f, 0x24d: 0x70, 0x24e: 0x71, 0x24f: 0x72, - 0x250: 0x73, 0x251: 0x74, 0x252: 0x75, 0x253: 0x6f, 0x254: 0x70, 0x255: 0x71, 0x256: 0x72, 0x257: 0x73, - 0x258: 0x74, 0x259: 0x75, 0x25a: 0x6f, 0x25b: 0x70, 0x25c: 0x71, 0x25d: 0x72, 0x25e: 0x73, 0x25f: 0x74, - 0x260: 0x75, 0x261: 0x6f, 0x262: 0x70, 0x263: 0x71, 0x264: 0x72, 0x265: 0x73, 0x266: 0x74, 0x267: 0x75, - 0x268: 0x6f, 0x269: 0x70, 0x26a: 0x71, 0x26b: 0x72, 0x26c: 0x73, 0x26d: 0x74, 0x26e: 0x75, 0x26f: 0x6f, - 0x270: 0x70, 0x271: 0x71, 0x272: 0x72, 0x273: 0x73, 0x274: 0x74, 0x275: 0x75, 0x276: 0x6f, 0x277: 0x70, - 0x278: 0x71, 0x279: 0x72, 0x27a: 0x73, 0x27b: 0x74, 0x27c: 0x75, 0x27d: 0x6f, 0x27e: 0x70, 0x27f: 0x71, + 0x240: 0x72, 0x241: 0x73, 0x242: 0x74, 0x243: 0x75, 0x244: 0x76, 0x245: 0x70, 0x246: 0x71, 0x247: 0x72, + 0x248: 0x73, 0x249: 0x74, 0x24a: 0x75, 0x24b: 0x76, 0x24c: 0x70, 0x24d: 0x71, 0x24e: 0x72, 0x24f: 0x73, + 0x250: 0x74, 0x251: 0x75, 0x252: 0x76, 0x253: 0x70, 0x254: 0x71, 0x255: 0x72, 0x256: 0x73, 0x257: 0x74, + 0x258: 0x75, 0x259: 0x76, 0x25a: 0x70, 0x25b: 0x71, 0x25c: 0x72, 0x25d: 0x73, 0x25e: 0x74, 0x25f: 0x75, + 0x260: 0x76, 0x261: 0x70, 0x262: 0x71, 0x263: 0x72, 0x264: 0x73, 0x265: 0x74, 0x266: 0x75, 0x267: 0x76, + 0x268: 0x70, 0x269: 0x71, 0x26a: 0x72, 0x26b: 0x73, 0x26c: 0x74, 0x26d: 0x75, 0x26e: 0x76, 0x26f: 0x70, + 0x270: 0x71, 0x271: 0x72, 0x272: 0x73, 0x273: 0x74, 0x274: 0x75, 0x275: 0x76, 0x276: 0x70, 0x277: 0x71, + 0x278: 0x72, 0x279: 0x73, 0x27a: 0x74, 0x27b: 0x75, 0x27c: 0x76, 0x27d: 0x70, 0x27e: 0x71, 0x27f: 0x72, // Block 0xa, offset 0x280 - 0x280: 0x72, 0x281: 0x73, 0x282: 0x74, 0x283: 0x75, 0x284: 0x6f, 0x285: 0x70, 0x286: 0x71, 0x287: 0x72, - 0x288: 0x73, 0x289: 0x74, 0x28a: 0x75, 0x28b: 0x6f, 0x28c: 0x70, 0x28d: 0x71, 0x28e: 0x72, 0x28f: 0x73, - 0x290: 0x74, 0x291: 0x75, 0x292: 0x6f, 0x293: 0x70, 0x294: 0x71, 0x295: 0x72, 0x296: 0x73, 0x297: 0x74, - 0x298: 0x75, 0x299: 0x6f, 0x29a: 0x70, 0x29b: 0x71, 0x29c: 0x72, 0x29d: 0x73, 0x29e: 0x74, 0x29f: 0x75, - 0x2a0: 0x6f, 0x2a1: 0x70, 0x2a2: 0x71, 0x2a3: 0x72, 0x2a4: 0x73, 0x2a5: 0x74, 0x2a6: 0x75, 0x2a7: 0x6f, - 0x2a8: 0x70, 0x2a9: 0x71, 0x2aa: 0x72, 0x2ab: 0x73, 0x2ac: 0x74, 0x2ad: 0x75, 0x2ae: 0x6f, 0x2af: 0x70, - 0x2b0: 0x71, 0x2b1: 0x72, 0x2b2: 0x73, 0x2b3: 0x74, 0x2b4: 0x75, 0x2b5: 0x6f, 0x2b6: 0x70, 0x2b7: 0x71, - 0x2b8: 0x72, 0x2b9: 0x73, 0x2ba: 0x74, 0x2bb: 0x75, 0x2bc: 0x6f, 0x2bd: 0x70, 0x2be: 0x71, 0x2bf: 0x72, + 0x280: 0x73, 0x281: 0x74, 0x282: 0x75, 0x283: 0x76, 0x284: 0x70, 0x285: 0x71, 0x286: 0x72, 0x287: 0x73, + 0x288: 0x74, 0x289: 0x75, 0x28a: 0x76, 0x28b: 0x70, 0x28c: 0x71, 0x28d: 0x72, 0x28e: 0x73, 0x28f: 0x74, + 0x290: 0x75, 0x291: 0x76, 0x292: 0x70, 0x293: 0x71, 0x294: 0x72, 0x295: 0x73, 0x296: 0x74, 0x297: 0x75, + 0x298: 0x76, 0x299: 0x70, 0x29a: 0x71, 0x29b: 0x72, 0x29c: 0x73, 0x29d: 0x74, 0x29e: 0x75, 0x29f: 0x76, + 0x2a0: 0x70, 0x2a1: 0x71, 0x2a2: 0x72, 0x2a3: 0x73, 0x2a4: 0x74, 0x2a5: 0x75, 0x2a6: 0x76, 0x2a7: 0x70, + 0x2a8: 0x71, 0x2a9: 0x72, 0x2aa: 0x73, 0x2ab: 0x74, 0x2ac: 0x75, 0x2ad: 0x76, 0x2ae: 0x70, 0x2af: 0x71, + 0x2b0: 0x72, 0x2b1: 0x73, 0x2b2: 0x74, 0x2b3: 0x75, 0x2b4: 0x76, 0x2b5: 0x70, 0x2b6: 0x71, 0x2b7: 0x72, + 0x2b8: 0x73, 0x2b9: 0x74, 0x2ba: 0x75, 0x2bb: 0x76, 0x2bc: 0x70, 0x2bd: 0x71, 0x2be: 0x72, 0x2bf: 0x73, // Block 0xb, offset 0x2c0 - 0x2c0: 0x73, 0x2c1: 0x74, 0x2c2: 0x75, 0x2c3: 0x6f, 0x2c4: 0x70, 0x2c5: 0x71, 0x2c6: 0x72, 0x2c7: 0x73, - 0x2c8: 0x74, 0x2c9: 0x75, 0x2ca: 0x6f, 0x2cb: 0x70, 0x2cc: 0x71, 0x2cd: 0x72, 0x2ce: 0x73, 0x2cf: 0x74, - 0x2d0: 0x75, 0x2d1: 0x6f, 0x2d2: 0x70, 0x2d3: 0x71, 0x2d4: 0x72, 0x2d5: 0x73, 0x2d6: 0x74, 0x2d7: 0x75, - 0x2d8: 0x6f, 0x2d9: 0x70, 0x2da: 0x71, 0x2db: 0x72, 0x2dc: 0x73, 0x2dd: 0x74, 0x2de: 0x76, 0x2df: 0x77, + 0x2c0: 0x74, 0x2c1: 0x75, 0x2c2: 0x76, 0x2c3: 0x70, 0x2c4: 0x71, 0x2c5: 0x72, 0x2c6: 0x73, 0x2c7: 0x74, + 0x2c8: 0x75, 0x2c9: 0x76, 0x2ca: 0x70, 0x2cb: 0x71, 0x2cc: 0x72, 0x2cd: 0x73, 0x2ce: 0x74, 0x2cf: 0x75, + 0x2d0: 0x76, 0x2d1: 0x70, 0x2d2: 0x71, 0x2d3: 0x72, 0x2d4: 0x73, 0x2d5: 0x74, 0x2d6: 0x75, 0x2d7: 0x76, + 0x2d8: 0x70, 0x2d9: 0x71, 0x2da: 0x72, 0x2db: 0x73, 0x2dc: 0x74, 0x2dd: 0x75, 0x2de: 0x77, 0x2df: 0x78, // Block 0xc, offset 0x300 - 0x32c: 0x78, - 0x338: 0x79, 0x33b: 0x7a, 0x33e: 0x61, 0x33f: 0x7b, + 0x32c: 0x79, + 0x338: 0x7a, 0x33b: 0x7b, 0x33e: 0x62, 0x33f: 0x7c, // Block 0xd, offset 0x340 - 0x347: 0x7c, - 0x34b: 0x7d, 0x34d: 0x7e, - 0x368: 0x7f, 0x36b: 0x80, - 0x374: 0x81, - 0x37a: 0x82, 0x37b: 0x83, 0x37d: 0x84, 0x37e: 0x85, + 0x347: 0x7d, + 0x34b: 0x7e, 0x34d: 0x7f, + 0x368: 0x80, 0x36b: 0x81, + 0x374: 0x82, 0x375: 0x83, + 0x37a: 0x84, 0x37b: 0x85, 0x37d: 0x86, 0x37e: 0x87, // Block 0xe, offset 0x380 - 0x380: 0x86, 0x381: 0x87, 0x382: 0x88, 0x383: 0x89, 0x384: 0x8a, 0x385: 0x8b, 0x386: 0x8c, 0x387: 0x8d, - 0x388: 0x8e, 0x389: 0x8f, 0x38b: 0x90, 0x38c: 0x21, 0x38d: 0x91, - 0x390: 0x92, 0x391: 0x93, 0x392: 0x94, 0x393: 0x95, 0x396: 0x96, 0x397: 0x97, - 0x398: 0x98, 0x399: 0x99, 0x39a: 0x9a, 0x39c: 0x9b, - 0x3a0: 0x9c, 0x3a4: 0x9d, 0x3a5: 0x9e, 0x3a7: 0x9f, - 0x3a8: 0xa0, 0x3a9: 0xa1, 0x3aa: 0xa2, - 0x3b0: 0xa3, 0x3b2: 0xa4, 0x3b4: 0xa5, 0x3b5: 0xa6, 0x3b6: 0xa7, - 0x3bb: 0xa8, 0x3bc: 0xa9, 0x3bd: 0xaa, + 0x380: 0x88, 0x381: 0x89, 0x382: 0x8a, 0x383: 0x8b, 0x384: 0x8c, 0x385: 0x8d, 0x386: 0x8e, 0x387: 0x8f, + 0x388: 0x90, 0x389: 0x91, 0x38b: 0x92, 0x38c: 0x93, 0x38d: 0x94, 0x38e: 0x95, 0x38f: 0x96, + 0x390: 0x97, 0x391: 0x98, 0x392: 0x99, 0x393: 0x9a, 0x396: 0x9b, 0x397: 0x9c, + 0x398: 0x9d, 0x399: 0x9e, 0x39a: 0x9f, 0x39c: 0xa0, + 0x3a0: 0xa1, 0x3a4: 0xa2, 0x3a5: 0xa3, 0x3a7: 0xa4, + 0x3a8: 0xa5, 0x3a9: 0xa6, 0x3aa: 0xa7, 0x3ad: 0xa8, + 0x3b0: 0xa9, 0x3b2: 0xaa, 0x3b4: 0xab, 0x3b5: 0xac, 0x3b6: 0xad, + 0x3bb: 0xae, 0x3bc: 0xaf, 0x3bd: 0xb0, // Block 0xf, offset 0x3c0 - 0x3d0: 0xab, 0x3d1: 0xac, + 0x3d0: 0xb1, 0x3d1: 0xb2, // Block 0x10, offset 0x400 - 0x42b: 0xad, 0x42c: 0xae, - 0x43d: 0xaf, 0x43e: 0xb0, 0x43f: 0xb1, + 0x404: 0xb3, + 0x42b: 0xb4, 0x42c: 0xb5, + 0x435: 0xb6, + 0x43d: 0xb7, 0x43e: 0xb8, 0x43f: 0xb9, // Block 0x11, offset 0x440 - 0x472: 0xb2, + 0x472: 0xba, // Block 0x12, offset 0x480 - 0x4bc: 0xb3, 0x4bd: 0xb4, + 0x4bc: 0xbb, 0x4bd: 0xbc, // Block 0x13, offset 0x4c0 - 0x4c5: 0xb5, 0x4c6: 0xb6, - 0x4c9: 0xb7, - 0x4e8: 0xb8, 0x4e9: 0xb9, 0x4ea: 0xba, + 0x4c5: 0xbd, 0x4c6: 0xbe, + 0x4c9: 0xbf, + 0x4e8: 0xc0, 0x4e9: 0xc1, 0x4ea: 0xc2, // Block 0x14, offset 0x500 - 0x500: 0xbb, 0x502: 0xbc, 0x504: 0xae, - 0x50a: 0xbd, 0x50b: 0xbe, - 0x513: 0xbe, - 0x523: 0xbf, 0x525: 0xc0, + 0x500: 0xc3, 0x502: 0xc4, 0x504: 0xb5, + 0x50a: 0xc5, 0x50b: 0xc6, + 0x513: 0xc6, 0x517: 0xc7, + 0x51b: 0xc8, + 0x523: 0xc9, 0x525: 0xca, // Block 0x15, offset 0x540 - 0x540: 0x52, 0x541: 0x52, 0x542: 0x52, 0x543: 0x52, 0x544: 0xc1, 0x545: 0xc2, 0x546: 0xc3, 0x547: 0xc4, - 0x548: 0xc5, 0x549: 0xc6, 0x54a: 0x52, 0x54b: 0x52, 0x54c: 0x52, 0x54d: 0x52, 0x54e: 0x52, 0x54f: 0xc7, - 0x550: 0x52, 0x551: 0x52, 0x552: 0x52, 0x553: 0x52, 0x554: 0xc8, 0x555: 0xc9, 0x556: 0x52, 0x557: 0x52, - 0x558: 0x52, 0x559: 0xca, 0x55a: 0x52, 0x55b: 0x52, 0x55d: 0xcb, 0x55f: 0xcc, - 0x560: 0xcd, 0x561: 0xce, 0x562: 0xcf, 0x563: 0x52, 0x564: 0xd0, 0x565: 0xd1, 0x566: 0x52, 0x567: 0x52, - 0x568: 0x52, 0x569: 0x52, 0x56a: 0x52, 0x56b: 0x52, - 0x570: 0x52, 0x571: 0x52, 0x572: 0x52, 0x573: 0x52, 0x574: 0x52, 0x575: 0x52, 0x576: 0x52, 0x577: 0x52, - 0x578: 0x52, 0x579: 0x52, 0x57a: 0x52, 0x57b: 0x52, 0x57c: 0x52, 0x57d: 0x52, 0x57e: 0x52, 0x57f: 0xc8, + 0x540: 0xcb, 0x542: 0xcc, 0x543: 0xcd, 0x545: 0xce, 0x546: 0xcf, 0x547: 0xd0, + 0x548: 0xd1, 0x549: 0xd2, 0x54a: 0xd3, 0x54b: 0xd3, 0x54c: 0xd4, 0x54d: 0xd3, 0x54e: 0xd5, 0x54f: 0xd6, + 0x550: 0xd3, 0x551: 0xd3, 0x552: 0xd3, 0x553: 0xd7, 0x554: 0xd8, 0x555: 0xd9, 0x556: 0xda, 0x557: 0xdb, + 0x558: 0xd3, 0x559: 0xdc, 0x55a: 0xd3, 0x55b: 0xdd, 0x55f: 0xde, + 0x560: 0xdf, 0x561: 0xe0, 0x562: 0xe1, 0x563: 0xe2, 0x564: 0xe3, 0x565: 0xe4, 0x566: 0xd3, 0x567: 0xd3, + 0x569: 0xe5, 0x56a: 0xd3, 0x56b: 0xd3, + 0x570: 0xd3, 0x571: 0xd3, 0x572: 0xd3, 0x573: 0xd3, 0x574: 0xd3, 0x575: 0xd3, 0x576: 0xd3, 0x577: 0xd3, + 0x578: 0xd3, 0x579: 0xd3, 0x57a: 0xd3, 0x57b: 0xd3, 0x57c: 0xd3, 0x57d: 0xd3, 0x57e: 0xd3, 0x57f: 0xd8, // Block 0x16, offset 0x580 0x590: 0x0b, 0x591: 0x0c, 0x593: 0x0d, 0x596: 0x0e, 0x59b: 0x0f, 0x59c: 0x10, 0x59d: 0x11, 0x59e: 0x12, 0x59f: 0x13, // Block 0x17, offset 0x5c0 - 0x5c0: 0xd2, 0x5c1: 0x02, 0x5c2: 0xd3, 0x5c3: 0xd3, 0x5c4: 0x02, 0x5c5: 0x02, 0x5c6: 0x02, 0x5c7: 0xd4, - 0x5c8: 0xd3, 0x5c9: 0xd3, 0x5ca: 0xd3, 0x5cb: 0xd3, 0x5cc: 0xd3, 0x5cd: 0xd3, 0x5ce: 0xd3, 0x5cf: 0xd3, - 0x5d0: 0xd3, 0x5d1: 0xd3, 0x5d2: 0xd3, 0x5d3: 0xd3, 0x5d4: 0xd3, 0x5d5: 0xd3, 0x5d6: 0xd3, 0x5d7: 0xd3, - 0x5d8: 0xd3, 0x5d9: 0xd3, 0x5da: 0xd3, 0x5db: 0xd3, 0x5dc: 0xd3, 0x5dd: 0xd3, 0x5de: 0xd3, 0x5df: 0xd3, - 0x5e0: 0xd3, 0x5e1: 0xd3, 0x5e2: 0xd3, 0x5e3: 0xd3, 0x5e4: 0xd3, 0x5e5: 0xd3, 0x5e6: 0xd3, 0x5e7: 0xd3, - 0x5e8: 0xd3, 0x5e9: 0xd3, 0x5ea: 0xd3, 0x5eb: 0xd3, 0x5ec: 0xd3, 0x5ed: 0xd3, 0x5ee: 0xd3, 0x5ef: 0xd3, - 0x5f0: 0xd3, 0x5f1: 0xd3, 0x5f2: 0xd3, 0x5f3: 0xd3, 0x5f4: 0xd3, 0x5f5: 0xd3, 0x5f6: 0xd3, 0x5f7: 0xd3, - 0x5f8: 0xd3, 0x5f9: 0xd3, 0x5fa: 0xd3, 0x5fb: 0xd3, 0x5fc: 0xd3, 0x5fd: 0xd3, 0x5fe: 0xd3, 0x5ff: 0xd3, + 0x5c0: 0xe6, 0x5c1: 0x02, 0x5c2: 0xe7, 0x5c3: 0xe7, 0x5c4: 0x02, 0x5c5: 0x02, 0x5c6: 0x02, 0x5c7: 0xe8, + 0x5c8: 0xe7, 0x5c9: 0xe7, 0x5ca: 0xe7, 0x5cb: 0xe7, 0x5cc: 0xe7, 0x5cd: 0xe7, 0x5ce: 0xe7, 0x5cf: 0xe7, + 0x5d0: 0xe7, 0x5d1: 0xe7, 0x5d2: 0xe7, 0x5d3: 0xe7, 0x5d4: 0xe7, 0x5d5: 0xe7, 0x5d6: 0xe7, 0x5d7: 0xe7, + 0x5d8: 0xe7, 0x5d9: 0xe7, 0x5da: 0xe7, 0x5db: 0xe7, 0x5dc: 0xe7, 0x5dd: 0xe7, 0x5de: 0xe7, 0x5df: 0xe7, + 0x5e0: 0xe7, 0x5e1: 0xe7, 0x5e2: 0xe7, 0x5e3: 0xe7, 0x5e4: 0xe7, 0x5e5: 0xe7, 0x5e6: 0xe7, 0x5e7: 0xe7, + 0x5e8: 0xe7, 0x5e9: 0xe7, 0x5ea: 0xe7, 0x5eb: 0xe7, 0x5ec: 0xe7, 0x5ed: 0xe7, 0x5ee: 0xe7, 0x5ef: 0xe7, + 0x5f0: 0xe7, 0x5f1: 0xe7, 0x5f2: 0xe7, 0x5f3: 0xe7, 0x5f4: 0xe7, 0x5f5: 0xe7, 0x5f6: 0xe7, 0x5f7: 0xe7, + 0x5f8: 0xe7, 0x5f9: 0xe7, 0x5fa: 0xe7, 0x5fb: 0xe7, 0x5fc: 0xe7, 0x5fd: 0xe7, 0x5fe: 0xe7, 0x5ff: 0xe7, // Block 0x18, offset 0x600 0x620: 0x15, } diff --git a/vendor/github.com/clipperhouse/uax29/v2/internal/iterators/iterator.go b/vendor/github.com/clipperhouse/uax29/v2/internal/iterators/iterator.go deleted file mode 100644 index e2134863..00000000 --- a/vendor/github.com/clipperhouse/uax29/v2/internal/iterators/iterator.go +++ /dev/null @@ -1,100 +0,0 @@ -package iterators - -import "github.com/clipperhouse/stringish" - -type SplitFunc[T stringish.Interface] func(T, bool) (int, T, error) - -// Iterator is a generic iterator for words that are either []byte or string. -// Iterate while Next() is true, and access the word via Value(). -type Iterator[T stringish.Interface] struct { - split SplitFunc[T] - data T - start int - pos int -} - -// New creates a new Iterator for the given data and SplitFunc. -func New[T stringish.Interface](split SplitFunc[T], data T) *Iterator[T] { - return &Iterator[T]{ - split: split, - data: data, - } -} - -// SetText sets the text for the iterator to operate on, and resets all state. -func (iter *Iterator[T]) SetText(data T) { - iter.data = data - iter.start = 0 - iter.pos = 0 -} - -// Split sets the SplitFunc for the Iterator. -func (iter *Iterator[T]) Split(split SplitFunc[T]) { - iter.split = split -} - -// Next advances the iterator to the next token. It returns false when there -// are no remaining tokens or an error occurred. -func (iter *Iterator[T]) Next() bool { - if iter.pos == len(iter.data) { - return false - } - if iter.pos > len(iter.data) { - panic("SplitFunc advanced beyond the end of the data") - } - - iter.start = iter.pos - - advance, _, err := iter.split(iter.data[iter.pos:], true) - if err != nil { - panic(err) - } - if advance <= 0 { - panic("SplitFunc returned a zero or negative advance") - } - - iter.pos += advance - if iter.pos > len(iter.data) { - panic("SplitFunc advanced beyond the end of the data") - } - - return true -} - -// Value returns the current token. -func (iter *Iterator[T]) Value() T { - return iter.data[iter.start:iter.pos] -} - -// Start returns the byte position of the current token in the original data. -func (iter *Iterator[T]) Start() int { - return iter.start -} - -// End returns the byte position after the current token in the original data. -func (iter *Iterator[T]) End() int { - return iter.pos -} - -// Reset resets the iterator to the beginning of the data. -func (iter *Iterator[T]) Reset() { - iter.start = 0 - iter.pos = 0 -} - -func (iter *Iterator[T]) First() T { - if len(iter.data) == 0 { - return iter.data - } - advance, _, err := iter.split(iter.data, true) - if err != nil { - panic(err) - } - if advance <= 0 { - panic("SplitFunc returned a zero or negative advance") - } - if advance > len(iter.data) { - panic("SplitFunc advanced beyond the end of the data") - } - return iter.data[:advance] -} diff --git a/vendor/github.com/coreos/go-systemd/v22/journal/journal_unix.go b/vendor/github.com/coreos/go-systemd/v22/journal/journal_unix.go index 6266e16e..55cb9eb2 100644 --- a/vendor/github.com/coreos/go-systemd/v22/journal/journal_unix.go +++ b/vendor/github.com/coreos/go-systemd/v22/journal/journal_unix.go @@ -106,7 +106,7 @@ func fdIsJournalStream(fd int) (bool, error) { var expectedStat syscall.Stat_t _, err := fmt.Sscanf(journalStream, "%d:%d", &expectedStat.Dev, &expectedStat.Ino) if err != nil { - return false, fmt.Errorf("failed to parse JOURNAL_STREAM=%q: %v", journalStream, err) + return false, fmt.Errorf("failed to parse JOURNAL_STREAM=%q: %w", journalStream, err) } var stat syscall.Stat_t diff --git a/vendor/github.com/ebitengine/purego/README.md b/vendor/github.com/ebitengine/purego/README.md index 523e9118..8fb85c2c 100644 --- a/vendor/github.com/ebitengine/purego/README.md +++ b/vendor/github.com/ebitengine/purego/README.md @@ -30,8 +30,8 @@ except for float arguments and return values. 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**: amd64, arm64 -- **iOS**: amd64, arm64 +- **Android**: amd641, arm641 +- **iOS**: amd641, arm641 - **Linux**: amd64, arm64 - **macOS**: amd64, arm64 - **Windows**: amd64, arm64 @@ -40,12 +40,17 @@ Tier 1 platforms are the primary targets officially supported by PureGo. When a Tier 2 platforms are supported by PureGo on a best-effort basis. Critical bugs on Tier 2 platforms do not block new PureGo releases. However, fixes contributed by external contributors are very welcome and encouraged. -- **Android**: 386, arm -- **FreeBSD**: amd64, arm64 -- **Linux**: 386, arm, loong64 -- **Windows**: 386*, arm* +- **Android**: 3861, arm1 +- **FreeBSD**: amd642, arm642 +- **Linux**: 386, arm, loong64, ppc64le, riscv64, s390x1 +- **Windows**: 3863, arm3,4 -`*` These architectures only support `SyscallN` and `NewCallback` +#### 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 @@ -103,11 +108,12 @@ This is a list of the copied files: * `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/cgo.go b/vendor/github.com/ebitengine/purego/cgo.go index 32bb256a..b6def570 100644 --- a/vendor/github.com/ebitengine/purego/cgo.go +++ b/vendor/github.com/ebitengine/purego/cgo.go @@ -7,8 +7,8 @@ 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/dlfcn_darwin.go b/vendor/github.com/ebitengine/purego/dlfcn_darwin.go index 27f56071..5dd44468 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_stubs.s b/vendor/github.com/ebitengine/purego/dlfcn_stubs.s index 9801e2dc..801e7467 100644 --- a/vendor/github.com/ebitengine/purego/dlfcn_stubs.s +++ b/vendor/github.com/ebitengine/purego/dlfcn_stubs.s @@ -8,19 +8,15 @@ // func dlopen(path *byte, mode int) (ret uintptr) TEXT dlopen(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_dlopen(SB) - RET // func dlsym(handle uintptr, symbol *byte) (ret uintptr) TEXT dlsym(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_dlsym(SB) - RET // func dlerror() (ret *byte) TEXT dlerror(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_dlerror(SB) - RET // func dlclose(handle uintptr) (ret int) TEXT dlclose(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_dlclose(SB) - RET diff --git a/vendor/github.com/ebitengine/purego/func.go b/vendor/github.com/ebitengine/purego/func.go index ee611b91..0da2c269 100644 --- a/vendor/github.com/ebitengine/purego/func.go +++ b/vendor/github.com/ebitengine/purego/func.go @@ -10,11 +10,16 @@ import ( "math" "reflect" "runtime" - "strconv" "sync" "unsafe" "github.com/ebitengine/purego/internal/strings" + "github.com/ebitengine/purego/internal/xreflect" +) + +const ( + align8ByteMask = 7 // Mask for 8-byte alignment: (val + 7) &^ 7 + align8ByteSize = 8 // 8-byte alignment boundary ) var thePool = sync.Pool{New: func() any { @@ -59,7 +64,7 @@ func RegisterLibFunc(fptr any, handle uintptr, name string) { // int64 <=> 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* @@ -94,6 +99,9 @@ func RegisterLibFunc(fptr any, 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: @@ -112,6 +120,7 @@ func RegisterLibFunc(fptr any, handle uintptr, name string) { // // [Cgo rules]: https://pkg.go.dev/cmd/cgo#hdr-Go_references_to_C func RegisterFunc(fptr any, cfn uintptr) { + const is32bit = unsafe.Sizeof(uintptr(0)) == 4 fn := reflect.ValueOf(fptr).Elem() ty := fn.Type() if ty.Kind() != reflect.Func { @@ -124,7 +133,7 @@ func RegisterFunc(fptr any, 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 != "loong64" { + 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") } { @@ -158,19 +167,13 @@ func RegisterFunc(fptr any, 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 < numOfFloatRegisters { + 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 } @@ -189,9 +192,7 @@ func RegisterFunc(fptr any, 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 { @@ -200,14 +201,29 @@ func RegisterFunc(fptr any, 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) { var sysargs [maxArgs]uintptr - var floats [numOfFloatRegisters]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 @@ -227,7 +243,7 @@ func RegisterFunc(fptr any, cfn uintptr) { } } addFloat = func(x uintptr) { - if numFloats < len(floats) { + if numFloats < numOfFloatRegisters() { floats[numFloats] = x numFloats++ } else { @@ -257,7 +273,7 @@ func RegisterFunc(fptr any, cfn uintptr) { var arm64_r8 uintptr if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { outType := ty.Out(0) - if (runtime.GOARCH == "amd64" || runtime.GOARCH == "loong64") && 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()) @@ -271,7 +287,7 @@ func RegisterFunc(fptr any, cfn uintptr) { } } for i, v := range args { - if variadic, ok := args[i].Interface().([]any); ok { + if variadic, ok := xreflect.TypeAssert[[]any](args[i]); ok { if i != len(args)-1 { panic("purego: can only expand last parameter") } @@ -280,28 +296,15 @@ func RegisterFunc(fptr any, cfn uintptr) { } continue } - if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && - (numInts >= numOfIntegerRegisters() || numFloats >= numOfFloatRegisters) && v.Kind() != reflect.Struct { // hit the stack - fields := make([]reflect.StructField, len(args[i:])) + // 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 - for j, val := range args[i:] { - if val.Kind() == reflect.String { - ptr := strings.CString(val.String()) - keepAlive = append(keepAlive, ptr) - val = reflect.ValueOf(ptr) - args[i+j] = val - } - fields[j] = reflect.StructField{ - Name: "X" + strconv.Itoa(j), - Type: val.Type(), - } - } - structType := reflect.StructOf(fields) - structInstance := reflect.New(structType).Elem() - for j, val := range args[i:] { - structInstance.Field(j).Set(val) - } - placeRegisters(structInstance, addFloat, addInt) + // Bundle stack arguments with C-style packing + bundleStackArgs(stackArgs, addStack) break } keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) @@ -310,26 +313,12 @@ func RegisterFunc(fptr any, cfn uintptr) { syscall := thePool.Get().(*syscall15Args) defer thePool.Put(syscall) - if runtime.GOARCH == "loong64" { - *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], - 0, - } + 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], - arm64_r8, - } + syscall.Set(cfn, sysargs[:], floats[:], arm64_r8) runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) } else { *syscall = syscall15Args{} @@ -365,11 +354,28 @@ func RegisterFunc(fptr any, 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) default: @@ -387,6 +393,7 @@ func RegisterFunc(fptr any, cfn uintptr) { } 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()) @@ -408,9 +415,20 @@ func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat addInt(0) } case reflect.Float32: - addFloat(uintptr(math.Float32bits(float32(v.Float())))) + // 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: - addFloat(uintptr(math.Float64bits(v.Float()))) + 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: @@ -464,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", "loong64": + 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/internal/cgo/syscall_cgo_unix.go b/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go index 10393fec..1e39de3b 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 || loong64)) || netbsd +//go:build freebsd || (linux && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64)) || netbsd package cgo 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 00000000..245a5266 --- /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 00000000..7475ec8a --- /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 00000000..68034e60 --- /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 index aea4f8e6..e81df86a 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s @@ -9,32 +9,32 @@ // 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 +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) + MOVV R1, (22*8)(R3) // Initialize Go ABI environment - JAL runtime·load_g(SB) + JAL runtime·load_g(SB) - JAL runtime·cgocallback(SB) + JAL runtime·cgocallback(SB) RESTORE_R22_TO_R31((4*8)) RESTORE_F24_TO_F31((14*8)) - MOVV (22*8)(R3), R1 + MOVV (22*8)(R3), R1 - ADDV $(23*8), R3 + 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 00000000..6d1938cd --- /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 00000000..acf82c1b --- /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 00000000..b6446650 --- /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/fakecgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go new file mode 100644 index 00000000..384dab2a --- /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 39f5ff1f..00000000 --- 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 e3a060b9..a3ba6bc8 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_freebsd_amd64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_amd64.go deleted file mode 100644 index c9ff7156..00000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_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_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 a3b1cca5..9f380c1b 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 c9ff7156..00000000 --- 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_linux_loong64.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_loong64.go deleted file mode 100644 index 65293914..00000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_loong64.go +++ /dev/null @@ -1,92 +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 - - 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) - 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_util.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go index 771cb525..ee993baa 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go @@ -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/trampolines_386.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s new file mode 100644 index 00000000..cd3492ea --- /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 c9a3cc09..e4e4c75a 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 00000000..00b3177e --- /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 9dbdbc01..dceb1cac 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 index 15b33543..7596f0da 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s @@ -5,36 +5,38 @@ #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), R6 - MOVV (R6), R7 - CALL (R7) + 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), R5 - MOVV (R5), R6 - CALL (R6) + 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), R5 - MOVV (R5), R6 - CALL (R6) + 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), R5 - MOVV (R5), R6 - CALL (R6) + MOVV ·x_cgo_unsetenv_call(SB), R23 + MOVV (R23), R23 + CALL (R23) RET TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 @@ -48,24 +50,39 @@ TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 // func setg_trampoline(setg uintptr, g uintptr) TEXT ·setg_trampoline(SB), NOSPLIT, $0 MOVV G+8(FP), R4 - MOVV setg+0(FP), R5 - CALL (R5) + MOVV setg+0(FP), R23 + CALL (R23) RET -TEXT threadentry_trampoline(SB), NOSPLIT, $16 - MOVV R4, 8(R3) - MOVV ·threadentry_call(SB), R5 - MOVV (R5), R6 - CALL (R6) +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), R9 + 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 (R9) + 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 00000000..85f89556 --- /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 00000000..9298f8c7 --- /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 67% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go index 135f6d21..cc552e7d 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go @@ -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 { @@ -62,12 +56,6 @@ func abort() { call5(abortABI0, 0, 0, 0, 0, 0) } -//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_init(attr *pthread_attr_t) int32 { @@ -92,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 { @@ -174,10 +132,6 @@ var nanosleepABI0 = uintptr(unsafe.Pointer(&_nanosleep)) var _abort uint8 var abortABI0 = uintptr(unsafe.Pointer(&_abort)) -//go:linkname _sigaltstack _sigaltstack -var _sigaltstack uint8 -var sigaltstackABI0 = uintptr(unsafe.Pointer(&_sigaltstack)) - //go:linkname _pthread_attr_init _pthread_attr_init var _pthread_attr_init uint8 var pthread_attr_initABI0 = uintptr(unsafe.Pointer(&_pthread_attr_init)) @@ -194,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 8c4489f0..960f8168 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" @@ -14,17 +16,44 @@ package fakecgo //go:cgo_import_dynamic purego_sigfillset sigfillset "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_nanosleep nanosleep "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_abort abort "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_sigaltstack sigaltstack "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_create pthread_create "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_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 bbe1bd57..d6977559 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" @@ -14,17 +16,33 @@ package fakecgo //go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.7" //go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.7" //go:cgo_import_dynamic purego_abort abort "libc.so.7" -//go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so.7" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so" //go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so" -//go:cgo_import_dynamic purego_pthread_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 21652650..f6bad22c 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" @@ -14,17 +16,33 @@ package fakecgo //go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.6" //go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.6" //go:cgo_import_dynamic purego_abort abort "libc.so.6" -//go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so.6" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_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/symbols_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go similarity index 57% rename from vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_netbsd.go rename to vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go index 7c92bb0b..774402cf 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_netbsd.go +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go @@ -7,6 +7,8 @@ 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" @@ -19,12 +21,39 @@ 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 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 00000000..35ef7ac1 --- /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 00000000..da07005c --- /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 00000000..da07005c --- /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 00000000..81ef76f5 --- /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 c93d783d..8e1afff7 100644 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_stubs.s +++ b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s @@ -7,88 +7,49 @@ #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 _sigaltstack(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_sigaltstack(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 00000000..5eb0580e --- /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 00000000..62ee13d6 --- /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/struct_386.go b/vendor/github.com/ebitengine/purego/struct_386.go new file mode 100644 index 00000000..02c8ac45 --- /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 c4c2ad8f..c56f957a 100644 --- a/vendor/github.com/ebitengine/purego/struct_amd64.go +++ b/vendor/github.com/ebitengine/purego/struct_amd64.go @@ -169,9 +169,10 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp } 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 @@ -238,27 +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, reflect.Uintptr: - 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: not needed on amd64") + 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 00000000..1b580585 --- /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 8605e77b..5f347c83 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) { @@ -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() > numOfFloatRegisters { - *numFloats = numOfFloatRegisters + 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 @@ -177,7 +190,7 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr shift = 0 flushed = true class = _NO_CLASS - case reflect.Ptr: + case reflect.Ptr, reflect.UnsafePointer: addInt(f.Pointer()) shift = 0 flushed = true @@ -284,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 index da7f1a15..e5891401 100644 --- a/vendor/github.com/ebitengine/purego/struct_loong64.go +++ b/vendor/github.com/ebitengine/purego/struct_loong64.go @@ -156,7 +156,7 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr shift = 0 flushed = true class = _NO_CLASS - case reflect.Ptr: + case reflect.Ptr, reflect.UnsafePointer: addInt(f.Pointer()) shift = 0 flushed = true @@ -188,3 +188,26 @@ func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { 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 58ccc973..00000000 --- a/vendor/github.com/ebitengine/purego/struct_other.go +++ /dev/null @@ -1,20 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -//go:build !amd64 && !arm64 && !loong64 - -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: not needed on other platforms") -} 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 00000000..7c50dcbb --- /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 00000000..eac0b880 --- /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 00000000..7ec5e813 --- /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 00000000..82931413 --- /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 a364dd0c..15b24dd2 100644 --- a/vendor/github.com/ebitengine/purego/sys_amd64.s +++ b/vendor/github.com/ebitengine/purego/sys_amd64.s @@ -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 00000000..3a8ce0d0 --- /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 a4f5be72..40a2f4c1 100644 --- a/vendor/github.com/ebitengine/purego/sys_arm64.s +++ b/vendor/github.com/ebitengine/purego/sys_arm64.s @@ -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 index 0f34eaee..420b855c 100644 --- a/vendor/github.com/ebitengine/purego/sys_loong64.s +++ b/vendor/github.com/ebitengine/purego/sys_loong64.s @@ -39,58 +39,58 @@ 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 + 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 + 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 + 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_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) + MOVV syscall15Args_fn(R13), R12 + JAL (R12) // pop structure pointer - MOVV PTR_ADDRESS(R3), R13 - ADDV $STACK_SIZE, R3 + MOVV PTR_ADDRESS(R3), R13 + ADDV $STACK_SIZE, R3 // save R4, R5 - MOVV R4, syscall15Args_a1(R13) - MOVV R5, syscall15Args_a2(R13) + 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) + 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 00000000..391b30a9 --- /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 00000000..e7e887e1 --- /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 00000000..a044e34d --- /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 00000000..31aecbf3 --- /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 00000000..a97e9437 --- /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_loong64.s b/vendor/github.com/ebitengine/purego/sys_unix_loong64.s index 89dbd7d1..cd00f9c1 100644 --- a/vendor/github.com/ebitengine/purego/sys_unix_loong64.s +++ b/vendor/github.com/ebitengine/purego/sys_unix_loong64.s @@ -11,26 +11,26 @@ 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) + 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 + SUBV $(22*8), R3 // It is important to save R30 because the go assembler // uses it for move instructions for a variable. @@ -44,32 +44,32 @@ TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 // 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) + 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 + 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 + MOVV ·callbackWrap_call(SB), R4 + MOVV (R4), R4 // fn unsafe.Pointer + MOVV R13, R5 // frame (&callbackArgs{...}) + MOVV $0, R7 // ctxt uintptr - JAL crosscall2(SB) + JAL crosscall2(SB) // Get callback result. - MOVV $(callbackArgs__size)(R3), R13 - MOVV callbackArgs_result(R13), R4 + 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 + 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 00000000..37f0d8d6 --- /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 00000000..8341d5b0 --- /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 00000000..9eed6d29 --- /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 ccfc4982..7b45383d 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 || netbsd || windows +//go:build !386 && !arm && (darwin || freebsd || linux || netbsd || windows) package purego @@ -13,8 +13,7 @@ package purego type CDecl struct{} const ( - maxArgs = 15 - numOfFloatRegisters = 8 // arm64 and amd64 both have 8 float registers + maxArgs = 15 ) type syscall15Args struct { @@ -23,6 +22,34 @@ 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. 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 00000000..f9f37630 --- /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 7794c263..179167f4 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 || loong64) +//go:build cgo && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || s390x) package purego @@ -17,5 +17,5 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a } func NewCallback(_ any) uintptr { - panic("purego: NewCallback on Linux is only supported on amd64/arm64/loong64") + 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 d794bc38..e35b32e7 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 || loong64)) || netbsd +// 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 @@ -19,13 +20,14 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a defer thePool.Put(args) *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, + 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 + return args.a1, args.a2, args.a3 } // NewCallback converts a Go function to a function pointer conforming to the C calling convention. @@ -58,22 +60,6 @@ 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 any) uintptr { val := reflect.ValueOf(fn) if val.Kind() != reflect.Func { @@ -145,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() + numOfFloatRegisters + // 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 >= numOfFloatRegisters { - 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 + numOfFloatRegisters + 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 { @@ -201,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, @@ -215,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", "loong64": - // 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 00000000..d4f6c7b7 --- /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 00000000..87ed9811 --- /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/zcallback_386.s b/vendor/github.com/ebitengine/purego/zcallback_386.s new file mode 100644 index 00000000..bd2d9c85 --- /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 42b54c48..b2da0225 100644 --- a/vendor/github.com/ebitengine/purego/zcallback_amd64.s +++ b/vendor/github.com/ebitengine/purego/zcallback_amd64.s @@ -11,2004 +11,2004 @@ // which Go callback function is executed later on. #include "textflag.h" -TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) +TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) + CALL callbackasm1(SB) 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 00000000..d969d81d --- /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 087c2d4f..3fea4af8 100644 --- a/vendor/github.com/ebitengine/purego/zcallback_arm64.s +++ b/vendor/github.com/ebitengine/purego/zcallback_arm64.s @@ -11,4004 +11,4004 @@ // It then calls the Go implementation for that callback. #include "textflag.h" -TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 - MOVD $0, R12 - B callbackasm1(SB) - MOVD $1, R12 - B callbackasm1(SB) - MOVD $2, R12 - B callbackasm1(SB) - MOVD $3, R12 - B callbackasm1(SB) - MOVD $4, R12 - B callbackasm1(SB) - MOVD $5, R12 - B callbackasm1(SB) - MOVD $6, R12 - B callbackasm1(SB) - MOVD $7, R12 - B callbackasm1(SB) - MOVD $8, R12 - B callbackasm1(SB) - MOVD $9, R12 - B callbackasm1(SB) - MOVD $10, R12 - B callbackasm1(SB) - MOVD $11, R12 - B callbackasm1(SB) - MOVD $12, R12 - B callbackasm1(SB) - MOVD $13, R12 - B callbackasm1(SB) - MOVD $14, R12 - B callbackasm1(SB) - MOVD $15, R12 - B callbackasm1(SB) - MOVD $16, R12 - B callbackasm1(SB) - MOVD $17, R12 - B callbackasm1(SB) - MOVD $18, R12 - B callbackasm1(SB) - MOVD $19, R12 - B callbackasm1(SB) - MOVD $20, R12 - B callbackasm1(SB) - MOVD $21, R12 - B callbackasm1(SB) - MOVD $22, R12 - B callbackasm1(SB) - MOVD $23, R12 - B callbackasm1(SB) - MOVD $24, R12 - B callbackasm1(SB) - MOVD $25, R12 - B callbackasm1(SB) - MOVD $26, R12 - B callbackasm1(SB) - MOVD $27, R12 - B callbackasm1(SB) - MOVD $28, R12 - B callbackasm1(SB) - MOVD $29, R12 - B callbackasm1(SB) - MOVD $30, R12 - B callbackasm1(SB) - MOVD $31, R12 - B callbackasm1(SB) - MOVD $32, R12 - B callbackasm1(SB) - MOVD $33, R12 - B callbackasm1(SB) - MOVD $34, R12 - B callbackasm1(SB) - MOVD $35, R12 - B callbackasm1(SB) - MOVD $36, R12 - B callbackasm1(SB) - MOVD $37, R12 - B callbackasm1(SB) - MOVD $38, R12 - B callbackasm1(SB) - MOVD $39, R12 - B callbackasm1(SB) - MOVD $40, R12 - B callbackasm1(SB) - MOVD $41, R12 - B callbackasm1(SB) - MOVD $42, R12 - B callbackasm1(SB) - MOVD $43, R12 - B callbackasm1(SB) - MOVD $44, R12 - B callbackasm1(SB) - MOVD $45, R12 - B callbackasm1(SB) - MOVD $46, R12 - B callbackasm1(SB) - MOVD $47, R12 - B callbackasm1(SB) - MOVD $48, R12 - B callbackasm1(SB) - MOVD $49, R12 - B callbackasm1(SB) - MOVD $50, R12 - B callbackasm1(SB) - MOVD $51, R12 - B callbackasm1(SB) - MOVD $52, R12 - B callbackasm1(SB) - MOVD $53, R12 - B callbackasm1(SB) - MOVD $54, R12 - B callbackasm1(SB) - MOVD $55, R12 - B callbackasm1(SB) - MOVD $56, R12 - B callbackasm1(SB) - MOVD $57, R12 - B callbackasm1(SB) - MOVD $58, R12 - B callbackasm1(SB) - MOVD $59, R12 - B callbackasm1(SB) - MOVD $60, R12 - B callbackasm1(SB) - MOVD $61, R12 - B callbackasm1(SB) - MOVD $62, R12 - B callbackasm1(SB) - MOVD $63, R12 - B callbackasm1(SB) - MOVD $64, R12 - B callbackasm1(SB) - MOVD $65, R12 - B callbackasm1(SB) - MOVD $66, R12 - B callbackasm1(SB) - MOVD $67, R12 - B callbackasm1(SB) - MOVD $68, R12 - B callbackasm1(SB) - MOVD $69, R12 - B callbackasm1(SB) - MOVD $70, R12 - B callbackasm1(SB) - MOVD $71, R12 - B callbackasm1(SB) - MOVD $72, R12 - B callbackasm1(SB) - MOVD $73, R12 - B callbackasm1(SB) - MOVD $74, R12 - B callbackasm1(SB) - MOVD $75, R12 - B callbackasm1(SB) - MOVD $76, R12 - B callbackasm1(SB) - MOVD $77, R12 - B callbackasm1(SB) - MOVD $78, R12 - B callbackasm1(SB) - MOVD $79, R12 - B callbackasm1(SB) - MOVD $80, R12 - B callbackasm1(SB) - MOVD $81, R12 - B callbackasm1(SB) - MOVD $82, R12 - B callbackasm1(SB) - MOVD $83, R12 - B callbackasm1(SB) - MOVD $84, R12 - B callbackasm1(SB) - MOVD $85, R12 - B callbackasm1(SB) - MOVD $86, R12 - B callbackasm1(SB) - MOVD $87, R12 - B callbackasm1(SB) - MOVD $88, R12 - B callbackasm1(SB) - MOVD $89, R12 - B callbackasm1(SB) - MOVD $90, R12 - B callbackasm1(SB) - MOVD $91, R12 - B callbackasm1(SB) - MOVD $92, R12 - B callbackasm1(SB) - MOVD $93, R12 - B callbackasm1(SB) - MOVD $94, R12 - B callbackasm1(SB) - MOVD $95, R12 - B callbackasm1(SB) - MOVD $96, R12 - B callbackasm1(SB) - MOVD $97, R12 - B callbackasm1(SB) - MOVD $98, R12 - B callbackasm1(SB) - MOVD $99, R12 - B callbackasm1(SB) - MOVD $100, R12 - B callbackasm1(SB) - MOVD $101, R12 - B callbackasm1(SB) - MOVD $102, R12 - B callbackasm1(SB) - MOVD $103, R12 - B callbackasm1(SB) - MOVD $104, R12 - B callbackasm1(SB) - MOVD $105, R12 - B callbackasm1(SB) - MOVD $106, R12 - B callbackasm1(SB) - MOVD $107, R12 - B callbackasm1(SB) - MOVD $108, R12 - B callbackasm1(SB) - MOVD $109, R12 - B callbackasm1(SB) - MOVD $110, R12 - B callbackasm1(SB) - MOVD $111, R12 - B callbackasm1(SB) - MOVD $112, R12 - B callbackasm1(SB) - MOVD $113, R12 - B callbackasm1(SB) - MOVD $114, R12 - B callbackasm1(SB) - MOVD $115, R12 - B callbackasm1(SB) - MOVD $116, R12 - B callbackasm1(SB) - MOVD $117, R12 - B callbackasm1(SB) - MOVD $118, R12 - B callbackasm1(SB) - MOVD $119, R12 - B callbackasm1(SB) - MOVD $120, R12 - B callbackasm1(SB) - MOVD $121, R12 - B callbackasm1(SB) - MOVD $122, R12 - B callbackasm1(SB) - MOVD $123, R12 - B callbackasm1(SB) - MOVD $124, R12 - B callbackasm1(SB) - MOVD $125, R12 - B callbackasm1(SB) - MOVD $126, R12 - B callbackasm1(SB) - MOVD $127, R12 - B callbackasm1(SB) - MOVD $128, R12 - B callbackasm1(SB) - MOVD $129, R12 - B callbackasm1(SB) - MOVD $130, R12 - B callbackasm1(SB) - MOVD $131, R12 - B callbackasm1(SB) - MOVD $132, R12 - B callbackasm1(SB) - MOVD $133, R12 - B callbackasm1(SB) - MOVD $134, R12 - B callbackasm1(SB) - MOVD $135, R12 - B callbackasm1(SB) - MOVD $136, R12 - B callbackasm1(SB) - MOVD $137, R12 - B callbackasm1(SB) - MOVD $138, R12 - B callbackasm1(SB) - MOVD $139, R12 - B callbackasm1(SB) - MOVD $140, R12 - B callbackasm1(SB) - MOVD $141, R12 - B callbackasm1(SB) - MOVD $142, R12 - B callbackasm1(SB) - MOVD $143, R12 - B callbackasm1(SB) - MOVD $144, R12 - B callbackasm1(SB) - MOVD $145, R12 - B callbackasm1(SB) - MOVD $146, R12 - B callbackasm1(SB) - MOVD $147, R12 - B callbackasm1(SB) - MOVD $148, R12 - B callbackasm1(SB) - MOVD $149, R12 - B callbackasm1(SB) - MOVD $150, R12 - B callbackasm1(SB) - MOVD $151, R12 - B callbackasm1(SB) - MOVD $152, R12 - B callbackasm1(SB) - MOVD $153, R12 - B callbackasm1(SB) - MOVD $154, R12 - B callbackasm1(SB) - MOVD $155, R12 - B callbackasm1(SB) - MOVD $156, R12 - B callbackasm1(SB) - MOVD $157, R12 - B callbackasm1(SB) - MOVD $158, R12 - B callbackasm1(SB) - MOVD $159, R12 - B callbackasm1(SB) - MOVD $160, R12 - B callbackasm1(SB) - MOVD $161, R12 - B callbackasm1(SB) - MOVD $162, R12 - B callbackasm1(SB) - MOVD $163, R12 - B callbackasm1(SB) - MOVD $164, R12 - B callbackasm1(SB) - MOVD $165, R12 - B callbackasm1(SB) - MOVD $166, R12 - B callbackasm1(SB) - MOVD $167, R12 - B callbackasm1(SB) - MOVD $168, R12 - B callbackasm1(SB) - MOVD $169, R12 - B callbackasm1(SB) - MOVD $170, R12 - B callbackasm1(SB) - MOVD $171, R12 - B callbackasm1(SB) - MOVD $172, R12 - B callbackasm1(SB) - MOVD $173, R12 - B callbackasm1(SB) - MOVD $174, R12 - B callbackasm1(SB) - MOVD $175, R12 - B callbackasm1(SB) - MOVD $176, R12 - B callbackasm1(SB) - MOVD $177, R12 - B callbackasm1(SB) - MOVD $178, R12 - B callbackasm1(SB) - MOVD $179, R12 - B callbackasm1(SB) - MOVD $180, R12 - B callbackasm1(SB) - MOVD $181, R12 - B callbackasm1(SB) - MOVD $182, R12 - B callbackasm1(SB) - MOVD $183, R12 - B callbackasm1(SB) - MOVD $184, R12 - B callbackasm1(SB) - MOVD $185, R12 - B callbackasm1(SB) - MOVD $186, R12 - B callbackasm1(SB) - MOVD $187, R12 - B callbackasm1(SB) - MOVD $188, R12 - B callbackasm1(SB) - MOVD $189, R12 - B callbackasm1(SB) - MOVD $190, R12 - B callbackasm1(SB) - MOVD $191, R12 - B callbackasm1(SB) - MOVD $192, R12 - B callbackasm1(SB) - MOVD $193, R12 - B callbackasm1(SB) - MOVD $194, R12 - B callbackasm1(SB) - MOVD $195, R12 - B callbackasm1(SB) - MOVD $196, R12 - B callbackasm1(SB) - MOVD $197, R12 - B callbackasm1(SB) - MOVD $198, R12 - B callbackasm1(SB) - MOVD $199, R12 - B callbackasm1(SB) - MOVD $200, R12 - B callbackasm1(SB) - MOVD $201, R12 - B callbackasm1(SB) - MOVD $202, R12 - B callbackasm1(SB) - MOVD $203, R12 - B callbackasm1(SB) - MOVD $204, R12 - B callbackasm1(SB) - MOVD $205, R12 - B callbackasm1(SB) - MOVD $206, R12 - B callbackasm1(SB) - MOVD $207, R12 - B callbackasm1(SB) - MOVD $208, R12 - B callbackasm1(SB) - MOVD $209, R12 - B callbackasm1(SB) - MOVD $210, R12 - B callbackasm1(SB) - MOVD $211, R12 - B callbackasm1(SB) - MOVD $212, R12 - B callbackasm1(SB) - MOVD $213, R12 - B callbackasm1(SB) - MOVD $214, R12 - B callbackasm1(SB) - MOVD $215, R12 - B callbackasm1(SB) - MOVD $216, R12 - B callbackasm1(SB) - MOVD $217, R12 - B callbackasm1(SB) - MOVD $218, R12 - B callbackasm1(SB) - MOVD $219, R12 - B callbackasm1(SB) - MOVD $220, R12 - B callbackasm1(SB) - MOVD $221, R12 - B callbackasm1(SB) - MOVD $222, R12 - B callbackasm1(SB) - MOVD $223, R12 - B callbackasm1(SB) - MOVD $224, R12 - B callbackasm1(SB) - MOVD $225, R12 - B callbackasm1(SB) - MOVD $226, R12 - B callbackasm1(SB) - MOVD $227, R12 - B callbackasm1(SB) - MOVD $228, R12 - B callbackasm1(SB) - MOVD $229, R12 - B callbackasm1(SB) - MOVD $230, R12 - B callbackasm1(SB) - MOVD $231, R12 - B callbackasm1(SB) - MOVD $232, R12 - B callbackasm1(SB) - MOVD $233, R12 - B callbackasm1(SB) - MOVD $234, R12 - B callbackasm1(SB) - MOVD $235, R12 - B callbackasm1(SB) - MOVD $236, R12 - B callbackasm1(SB) - MOVD $237, R12 - B callbackasm1(SB) - MOVD $238, R12 - B callbackasm1(SB) - MOVD $239, R12 - B callbackasm1(SB) - MOVD $240, R12 - B callbackasm1(SB) - MOVD $241, R12 - B callbackasm1(SB) - MOVD $242, R12 - B callbackasm1(SB) - MOVD $243, R12 - B callbackasm1(SB) - MOVD $244, R12 - B callbackasm1(SB) - MOVD $245, R12 - B callbackasm1(SB) - MOVD $246, R12 - B callbackasm1(SB) - MOVD $247, R12 - B callbackasm1(SB) - MOVD $248, R12 - B callbackasm1(SB) - MOVD $249, R12 - B callbackasm1(SB) - MOVD $250, R12 - B callbackasm1(SB) - MOVD $251, R12 - B callbackasm1(SB) - MOVD $252, R12 - B callbackasm1(SB) - MOVD $253, R12 - B callbackasm1(SB) - MOVD $254, R12 - B callbackasm1(SB) - MOVD $255, R12 - B callbackasm1(SB) - MOVD $256, R12 - B callbackasm1(SB) - MOVD $257, R12 - B callbackasm1(SB) - MOVD $258, R12 - B callbackasm1(SB) - MOVD $259, R12 - B callbackasm1(SB) - MOVD $260, R12 - B callbackasm1(SB) - MOVD $261, R12 - B callbackasm1(SB) - MOVD $262, R12 - B callbackasm1(SB) - MOVD $263, R12 - B callbackasm1(SB) - MOVD $264, R12 - B callbackasm1(SB) - MOVD $265, R12 - B callbackasm1(SB) - MOVD $266, R12 - B callbackasm1(SB) - MOVD $267, R12 - B callbackasm1(SB) - MOVD $268, R12 - B callbackasm1(SB) - MOVD $269, R12 - B callbackasm1(SB) - MOVD $270, R12 - B callbackasm1(SB) - MOVD $271, R12 - B callbackasm1(SB) - MOVD $272, R12 - B callbackasm1(SB) - MOVD $273, R12 - B callbackasm1(SB) - MOVD $274, R12 - B callbackasm1(SB) - MOVD $275, R12 - B callbackasm1(SB) - MOVD $276, R12 - B callbackasm1(SB) - MOVD $277, R12 - B callbackasm1(SB) - MOVD $278, R12 - B callbackasm1(SB) - MOVD $279, R12 - B callbackasm1(SB) - MOVD $280, R12 - B callbackasm1(SB) - MOVD $281, R12 - B callbackasm1(SB) - MOVD $282, R12 - B callbackasm1(SB) - MOVD $283, R12 - B callbackasm1(SB) - MOVD $284, R12 - B callbackasm1(SB) - MOVD $285, R12 - B callbackasm1(SB) - MOVD $286, R12 - B callbackasm1(SB) - MOVD $287, R12 - B callbackasm1(SB) - MOVD $288, R12 - B callbackasm1(SB) - MOVD $289, R12 - B callbackasm1(SB) - MOVD $290, R12 - B callbackasm1(SB) - MOVD $291, R12 - B callbackasm1(SB) - MOVD $292, R12 - B callbackasm1(SB) - MOVD $293, R12 - B callbackasm1(SB) - MOVD $294, R12 - B callbackasm1(SB) - MOVD $295, R12 - B callbackasm1(SB) - MOVD $296, R12 - B callbackasm1(SB) - MOVD $297, R12 - B callbackasm1(SB) - MOVD $298, R12 - B callbackasm1(SB) - MOVD $299, R12 - B callbackasm1(SB) - MOVD $300, R12 - B callbackasm1(SB) - MOVD $301, R12 - B callbackasm1(SB) - MOVD $302, R12 - B callbackasm1(SB) - MOVD $303, R12 - B callbackasm1(SB) - MOVD $304, R12 - B callbackasm1(SB) - MOVD $305, R12 - B callbackasm1(SB) - MOVD $306, R12 - B callbackasm1(SB) - MOVD $307, R12 - B callbackasm1(SB) - MOVD $308, R12 - B callbackasm1(SB) - MOVD $309, R12 - B callbackasm1(SB) - MOVD $310, R12 - B callbackasm1(SB) - MOVD $311, R12 - B callbackasm1(SB) - MOVD $312, R12 - B callbackasm1(SB) - MOVD $313, R12 - B callbackasm1(SB) - MOVD $314, R12 - B callbackasm1(SB) - MOVD $315, R12 - B callbackasm1(SB) - MOVD $316, R12 - B callbackasm1(SB) - MOVD $317, R12 - B callbackasm1(SB) - MOVD $318, R12 - B callbackasm1(SB) - MOVD $319, R12 - B callbackasm1(SB) - MOVD $320, R12 - B callbackasm1(SB) - MOVD $321, R12 - B callbackasm1(SB) - MOVD $322, R12 - B callbackasm1(SB) - MOVD $323, R12 - B callbackasm1(SB) - MOVD $324, R12 - B callbackasm1(SB) - MOVD $325, R12 - B callbackasm1(SB) - MOVD $326, R12 - B callbackasm1(SB) - MOVD $327, R12 - B callbackasm1(SB) - MOVD $328, R12 - B callbackasm1(SB) - MOVD $329, R12 - B callbackasm1(SB) - MOVD $330, R12 - B callbackasm1(SB) - MOVD $331, R12 - B callbackasm1(SB) - MOVD $332, R12 - B callbackasm1(SB) - MOVD $333, R12 - B callbackasm1(SB) - MOVD $334, R12 - B callbackasm1(SB) - MOVD $335, R12 - B callbackasm1(SB) - MOVD $336, R12 - B callbackasm1(SB) - MOVD $337, R12 - B callbackasm1(SB) - MOVD $338, R12 - B callbackasm1(SB) - MOVD $339, R12 - B callbackasm1(SB) - MOVD $340, R12 - B callbackasm1(SB) - MOVD $341, R12 - B callbackasm1(SB) - MOVD $342, R12 - B callbackasm1(SB) - MOVD $343, R12 - B callbackasm1(SB) - MOVD $344, R12 - B callbackasm1(SB) - MOVD $345, R12 - B callbackasm1(SB) - MOVD $346, R12 - B callbackasm1(SB) - MOVD $347, R12 - B callbackasm1(SB) - MOVD $348, R12 - B callbackasm1(SB) - MOVD $349, R12 - B callbackasm1(SB) - MOVD $350, R12 - B callbackasm1(SB) - MOVD $351, R12 - B callbackasm1(SB) - MOVD $352, R12 - B callbackasm1(SB) - MOVD $353, R12 - B callbackasm1(SB) - MOVD $354, R12 - B callbackasm1(SB) - MOVD $355, R12 - B callbackasm1(SB) - MOVD $356, R12 - B callbackasm1(SB) - MOVD $357, R12 - B callbackasm1(SB) - MOVD $358, R12 - B callbackasm1(SB) - MOVD $359, R12 - B callbackasm1(SB) - MOVD $360, R12 - B callbackasm1(SB) - MOVD $361, R12 - B callbackasm1(SB) - MOVD $362, R12 - B callbackasm1(SB) - MOVD $363, R12 - B callbackasm1(SB) - MOVD $364, R12 - B callbackasm1(SB) - MOVD $365, R12 - B callbackasm1(SB) - MOVD $366, R12 - B callbackasm1(SB) - MOVD $367, R12 - B callbackasm1(SB) - MOVD $368, R12 - B callbackasm1(SB) - MOVD $369, R12 - B callbackasm1(SB) - MOVD $370, R12 - B callbackasm1(SB) - MOVD $371, R12 - B callbackasm1(SB) - MOVD $372, R12 - B callbackasm1(SB) - MOVD $373, R12 - B callbackasm1(SB) - MOVD $374, R12 - B callbackasm1(SB) - MOVD $375, R12 - B callbackasm1(SB) - MOVD $376, R12 - B callbackasm1(SB) - MOVD $377, R12 - B callbackasm1(SB) - MOVD $378, R12 - B callbackasm1(SB) - MOVD $379, R12 - B callbackasm1(SB) - MOVD $380, R12 - B callbackasm1(SB) - MOVD $381, R12 - B callbackasm1(SB) - MOVD $382, R12 - B callbackasm1(SB) - MOVD $383, R12 - B callbackasm1(SB) - MOVD $384, R12 - B callbackasm1(SB) - MOVD $385, R12 - B callbackasm1(SB) - MOVD $386, R12 - B callbackasm1(SB) - MOVD $387, R12 - B callbackasm1(SB) - MOVD $388, R12 - B callbackasm1(SB) - MOVD $389, R12 - B callbackasm1(SB) - MOVD $390, R12 - B callbackasm1(SB) - MOVD $391, R12 - B callbackasm1(SB) - MOVD $392, R12 - B callbackasm1(SB) - MOVD $393, R12 - B callbackasm1(SB) - MOVD $394, R12 - B callbackasm1(SB) - MOVD $395, R12 - B callbackasm1(SB) - MOVD $396, R12 - B callbackasm1(SB) - MOVD $397, R12 - B callbackasm1(SB) - MOVD $398, R12 - B callbackasm1(SB) - MOVD $399, R12 - B callbackasm1(SB) - MOVD $400, R12 - B callbackasm1(SB) - MOVD $401, R12 - B callbackasm1(SB) - MOVD $402, R12 - B callbackasm1(SB) - MOVD $403, R12 - B callbackasm1(SB) - MOVD $404, R12 - B callbackasm1(SB) - MOVD $405, R12 - B callbackasm1(SB) - MOVD $406, R12 - B callbackasm1(SB) - MOVD $407, R12 - B callbackasm1(SB) - MOVD $408, R12 - B callbackasm1(SB) - MOVD $409, R12 - B callbackasm1(SB) - MOVD $410, R12 - B callbackasm1(SB) - MOVD $411, R12 - B callbackasm1(SB) - MOVD $412, R12 - B callbackasm1(SB) - MOVD $413, R12 - B callbackasm1(SB) - MOVD $414, R12 - B callbackasm1(SB) - MOVD $415, R12 - B callbackasm1(SB) - MOVD $416, R12 - B callbackasm1(SB) - MOVD $417, R12 - B callbackasm1(SB) - MOVD $418, R12 - B callbackasm1(SB) - MOVD $419, R12 - B callbackasm1(SB) - MOVD $420, R12 - B callbackasm1(SB) - MOVD $421, R12 - B callbackasm1(SB) - MOVD $422, R12 - B callbackasm1(SB) - MOVD $423, R12 - B callbackasm1(SB) - MOVD $424, R12 - B callbackasm1(SB) - MOVD $425, R12 - B callbackasm1(SB) - MOVD $426, R12 - B callbackasm1(SB) - MOVD $427, R12 - B callbackasm1(SB) - MOVD $428, R12 - B callbackasm1(SB) - MOVD $429, R12 - B callbackasm1(SB) - MOVD $430, R12 - B callbackasm1(SB) - MOVD $431, R12 - B callbackasm1(SB) - MOVD $432, R12 - B callbackasm1(SB) - MOVD $433, R12 - B callbackasm1(SB) - MOVD $434, R12 - B callbackasm1(SB) - MOVD $435, R12 - B callbackasm1(SB) - MOVD $436, R12 - B callbackasm1(SB) - MOVD $437, R12 - B callbackasm1(SB) - MOVD $438, R12 - B callbackasm1(SB) - MOVD $439, R12 - B callbackasm1(SB) - MOVD $440, R12 - B callbackasm1(SB) - MOVD $441, R12 - B callbackasm1(SB) - MOVD $442, R12 - B callbackasm1(SB) - MOVD $443, R12 - B callbackasm1(SB) - MOVD $444, R12 - B callbackasm1(SB) - MOVD $445, R12 - B callbackasm1(SB) - MOVD $446, R12 - B callbackasm1(SB) - MOVD $447, R12 - B callbackasm1(SB) - MOVD $448, R12 - B callbackasm1(SB) - MOVD $449, R12 - B callbackasm1(SB) - MOVD $450, R12 - B callbackasm1(SB) - MOVD $451, R12 - B callbackasm1(SB) - MOVD $452, R12 - B callbackasm1(SB) - MOVD $453, R12 - B callbackasm1(SB) - MOVD $454, R12 - B callbackasm1(SB) - MOVD $455, R12 - B callbackasm1(SB) - MOVD $456, R12 - B callbackasm1(SB) - MOVD $457, R12 - B callbackasm1(SB) - MOVD $458, R12 - B callbackasm1(SB) - MOVD $459, R12 - B callbackasm1(SB) - MOVD $460, R12 - B callbackasm1(SB) - MOVD $461, R12 - B callbackasm1(SB) - MOVD $462, R12 - B callbackasm1(SB) - MOVD $463, R12 - B callbackasm1(SB) - MOVD $464, R12 - B callbackasm1(SB) - MOVD $465, R12 - B callbackasm1(SB) - MOVD $466, R12 - B callbackasm1(SB) - MOVD $467, R12 - B callbackasm1(SB) - MOVD $468, R12 - B callbackasm1(SB) - MOVD $469, R12 - B callbackasm1(SB) - MOVD $470, R12 - B callbackasm1(SB) - MOVD $471, R12 - B callbackasm1(SB) - MOVD $472, R12 - B callbackasm1(SB) - MOVD $473, R12 - B callbackasm1(SB) - MOVD $474, R12 - B callbackasm1(SB) - MOVD $475, R12 - B callbackasm1(SB) - MOVD $476, R12 - B callbackasm1(SB) - MOVD $477, R12 - B callbackasm1(SB) - MOVD $478, R12 - B callbackasm1(SB) - MOVD $479, R12 - B callbackasm1(SB) - MOVD $480, R12 - B callbackasm1(SB) - MOVD $481, R12 - B callbackasm1(SB) - MOVD $482, R12 - B callbackasm1(SB) - MOVD $483, R12 - B callbackasm1(SB) - MOVD $484, R12 - B callbackasm1(SB) - MOVD $485, R12 - B callbackasm1(SB) - MOVD $486, R12 - B callbackasm1(SB) - MOVD $487, R12 - B callbackasm1(SB) - MOVD $488, R12 - B callbackasm1(SB) - MOVD $489, R12 - B callbackasm1(SB) - MOVD $490, R12 - B callbackasm1(SB) - MOVD $491, R12 - B callbackasm1(SB) - MOVD $492, R12 - B callbackasm1(SB) - MOVD $493, R12 - B callbackasm1(SB) - MOVD $494, R12 - B callbackasm1(SB) - MOVD $495, R12 - B callbackasm1(SB) - MOVD $496, R12 - B callbackasm1(SB) - MOVD $497, R12 - B callbackasm1(SB) - MOVD $498, R12 - B callbackasm1(SB) - MOVD $499, R12 - B callbackasm1(SB) - MOVD $500, R12 - B callbackasm1(SB) - MOVD $501, R12 - B callbackasm1(SB) - MOVD $502, R12 - B callbackasm1(SB) - MOVD $503, R12 - B callbackasm1(SB) - MOVD $504, R12 - B callbackasm1(SB) - MOVD $505, R12 - B callbackasm1(SB) - MOVD $506, R12 - B callbackasm1(SB) - MOVD $507, R12 - B callbackasm1(SB) - MOVD $508, R12 - B callbackasm1(SB) - MOVD $509, R12 - B callbackasm1(SB) - MOVD $510, R12 - B callbackasm1(SB) - MOVD $511, R12 - B callbackasm1(SB) - MOVD $512, R12 - B callbackasm1(SB) - MOVD $513, R12 - B callbackasm1(SB) - MOVD $514, R12 - B callbackasm1(SB) - MOVD $515, R12 - B callbackasm1(SB) - MOVD $516, R12 - B callbackasm1(SB) - MOVD $517, R12 - B callbackasm1(SB) - MOVD $518, R12 - B callbackasm1(SB) - MOVD $519, R12 - B callbackasm1(SB) - MOVD $520, R12 - B callbackasm1(SB) - MOVD $521, R12 - B callbackasm1(SB) - MOVD $522, R12 - B callbackasm1(SB) - MOVD $523, R12 - B callbackasm1(SB) - MOVD $524, R12 - B callbackasm1(SB) - MOVD $525, R12 - B callbackasm1(SB) - MOVD $526, R12 - B callbackasm1(SB) - MOVD $527, R12 - B callbackasm1(SB) - MOVD $528, R12 - B callbackasm1(SB) - MOVD $529, R12 - B callbackasm1(SB) - MOVD $530, R12 - B callbackasm1(SB) - MOVD $531, R12 - B callbackasm1(SB) - MOVD $532, R12 - B callbackasm1(SB) - MOVD $533, R12 - B callbackasm1(SB) - MOVD $534, R12 - B callbackasm1(SB) - MOVD $535, R12 - B callbackasm1(SB) - MOVD $536, R12 - B callbackasm1(SB) - MOVD $537, R12 - B callbackasm1(SB) - MOVD $538, R12 - B callbackasm1(SB) - MOVD $539, R12 - B callbackasm1(SB) - MOVD $540, R12 - B callbackasm1(SB) - MOVD $541, R12 - B callbackasm1(SB) - MOVD $542, R12 - B callbackasm1(SB) - MOVD $543, R12 - B callbackasm1(SB) - MOVD $544, R12 - B callbackasm1(SB) - MOVD $545, R12 - B callbackasm1(SB) - MOVD $546, R12 - B callbackasm1(SB) - MOVD $547, R12 - B callbackasm1(SB) - MOVD $548, R12 - B callbackasm1(SB) - MOVD $549, R12 - B callbackasm1(SB) - MOVD $550, R12 - B callbackasm1(SB) - MOVD $551, R12 - B callbackasm1(SB) - MOVD $552, R12 - B callbackasm1(SB) - MOVD $553, R12 - B callbackasm1(SB) - MOVD $554, R12 - B callbackasm1(SB) - MOVD $555, R12 - B callbackasm1(SB) - MOVD $556, R12 - B callbackasm1(SB) - MOVD $557, R12 - B callbackasm1(SB) - MOVD $558, R12 - B callbackasm1(SB) - MOVD $559, R12 - B callbackasm1(SB) - MOVD $560, R12 - B callbackasm1(SB) - MOVD $561, R12 - B callbackasm1(SB) - MOVD $562, R12 - B callbackasm1(SB) - MOVD $563, R12 - B callbackasm1(SB) - MOVD $564, R12 - B callbackasm1(SB) - MOVD $565, R12 - B callbackasm1(SB) - MOVD $566, R12 - B callbackasm1(SB) - MOVD $567, R12 - B callbackasm1(SB) - MOVD $568, R12 - B callbackasm1(SB) - MOVD $569, R12 - B callbackasm1(SB) - MOVD $570, R12 - B callbackasm1(SB) - MOVD $571, R12 - B callbackasm1(SB) - MOVD $572, R12 - B callbackasm1(SB) - MOVD $573, R12 - B callbackasm1(SB) - MOVD $574, R12 - B callbackasm1(SB) - MOVD $575, R12 - B callbackasm1(SB) - MOVD $576, R12 - B callbackasm1(SB) - MOVD $577, R12 - B callbackasm1(SB) - MOVD $578, R12 - B callbackasm1(SB) - MOVD $579, R12 - B callbackasm1(SB) - MOVD $580, R12 - B callbackasm1(SB) - MOVD $581, R12 - B callbackasm1(SB) - MOVD $582, R12 - B callbackasm1(SB) - MOVD $583, R12 - B callbackasm1(SB) - MOVD $584, R12 - B callbackasm1(SB) - MOVD $585, R12 - B callbackasm1(SB) - MOVD $586, R12 - B callbackasm1(SB) - MOVD $587, R12 - B callbackasm1(SB) - MOVD $588, R12 - B callbackasm1(SB) - MOVD $589, R12 - B callbackasm1(SB) - MOVD $590, R12 - B callbackasm1(SB) - MOVD $591, R12 - B callbackasm1(SB) - MOVD $592, R12 - B callbackasm1(SB) - MOVD $593, R12 - B callbackasm1(SB) - MOVD $594, R12 - B callbackasm1(SB) - MOVD $595, R12 - B callbackasm1(SB) - MOVD $596, R12 - B callbackasm1(SB) - MOVD $597, R12 - B callbackasm1(SB) - MOVD $598, R12 - B callbackasm1(SB) - MOVD $599, R12 - B callbackasm1(SB) - MOVD $600, R12 - B callbackasm1(SB) - MOVD $601, R12 - B callbackasm1(SB) - MOVD $602, R12 - B callbackasm1(SB) - MOVD $603, R12 - B callbackasm1(SB) - MOVD $604, R12 - B callbackasm1(SB) - MOVD $605, R12 - B callbackasm1(SB) - MOVD $606, R12 - B callbackasm1(SB) - MOVD $607, R12 - B callbackasm1(SB) - MOVD $608, R12 - B callbackasm1(SB) - MOVD $609, R12 - B callbackasm1(SB) - MOVD $610, R12 - B callbackasm1(SB) - MOVD $611, R12 - B callbackasm1(SB) - MOVD $612, R12 - B callbackasm1(SB) - MOVD $613, R12 - B callbackasm1(SB) - MOVD $614, R12 - B callbackasm1(SB) - MOVD $615, R12 - B callbackasm1(SB) - MOVD $616, R12 - B callbackasm1(SB) - MOVD $617, R12 - B callbackasm1(SB) - MOVD $618, R12 - B callbackasm1(SB) - MOVD $619, R12 - B callbackasm1(SB) - MOVD $620, R12 - B callbackasm1(SB) - MOVD $621, R12 - B callbackasm1(SB) - MOVD $622, R12 - B callbackasm1(SB) - MOVD $623, R12 - B callbackasm1(SB) - MOVD $624, R12 - B callbackasm1(SB) - MOVD $625, R12 - B callbackasm1(SB) - MOVD $626, R12 - B callbackasm1(SB) - MOVD $627, R12 - B callbackasm1(SB) - MOVD $628, R12 - B callbackasm1(SB) - MOVD $629, R12 - B callbackasm1(SB) - MOVD $630, R12 - B callbackasm1(SB) - MOVD $631, R12 - B callbackasm1(SB) - MOVD $632, R12 - B callbackasm1(SB) - MOVD $633, R12 - B callbackasm1(SB) - MOVD $634, R12 - B callbackasm1(SB) - MOVD $635, R12 - B callbackasm1(SB) - MOVD $636, R12 - B callbackasm1(SB) - MOVD $637, R12 - B callbackasm1(SB) - MOVD $638, R12 - B callbackasm1(SB) - MOVD $639, R12 - B callbackasm1(SB) - MOVD $640, R12 - B callbackasm1(SB) - MOVD $641, R12 - B callbackasm1(SB) - MOVD $642, R12 - B callbackasm1(SB) - MOVD $643, R12 - B callbackasm1(SB) - MOVD $644, R12 - B callbackasm1(SB) - MOVD $645, R12 - B callbackasm1(SB) - MOVD $646, R12 - B callbackasm1(SB) - MOVD $647, R12 - B callbackasm1(SB) - MOVD $648, R12 - B callbackasm1(SB) - MOVD $649, R12 - B callbackasm1(SB) - MOVD $650, R12 - B callbackasm1(SB) - MOVD $651, R12 - B callbackasm1(SB) - MOVD $652, R12 - B callbackasm1(SB) - MOVD $653, R12 - B callbackasm1(SB) - MOVD $654, R12 - B callbackasm1(SB) - MOVD $655, R12 - B callbackasm1(SB) - MOVD $656, R12 - B callbackasm1(SB) - MOVD $657, R12 - B callbackasm1(SB) - MOVD $658, R12 - B callbackasm1(SB) - MOVD $659, R12 - B callbackasm1(SB) - MOVD $660, R12 - B callbackasm1(SB) - MOVD $661, R12 - B callbackasm1(SB) - MOVD $662, R12 - B callbackasm1(SB) - MOVD $663, R12 - B callbackasm1(SB) - MOVD $664, R12 - B callbackasm1(SB) - MOVD $665, R12 - B callbackasm1(SB) - MOVD $666, R12 - B callbackasm1(SB) - MOVD $667, R12 - B callbackasm1(SB) - MOVD $668, R12 - B callbackasm1(SB) - MOVD $669, R12 - B callbackasm1(SB) - MOVD $670, R12 - B callbackasm1(SB) - MOVD $671, R12 - B callbackasm1(SB) - MOVD $672, R12 - B callbackasm1(SB) - MOVD $673, R12 - B callbackasm1(SB) - MOVD $674, R12 - B callbackasm1(SB) - MOVD $675, R12 - B callbackasm1(SB) - MOVD $676, R12 - B callbackasm1(SB) - MOVD $677, R12 - B callbackasm1(SB) - MOVD $678, R12 - B callbackasm1(SB) - MOVD $679, R12 - B callbackasm1(SB) - MOVD $680, R12 - B callbackasm1(SB) - MOVD $681, R12 - B callbackasm1(SB) - MOVD $682, R12 - B callbackasm1(SB) - MOVD $683, R12 - B callbackasm1(SB) - MOVD $684, R12 - B callbackasm1(SB) - MOVD $685, R12 - B callbackasm1(SB) - MOVD $686, R12 - B callbackasm1(SB) - MOVD $687, R12 - B callbackasm1(SB) - MOVD $688, R12 - B callbackasm1(SB) - MOVD $689, R12 - B callbackasm1(SB) - MOVD $690, R12 - B callbackasm1(SB) - MOVD $691, R12 - B callbackasm1(SB) - MOVD $692, R12 - B callbackasm1(SB) - MOVD $693, R12 - B callbackasm1(SB) - MOVD $694, R12 - B callbackasm1(SB) - MOVD $695, R12 - B callbackasm1(SB) - MOVD $696, R12 - B callbackasm1(SB) - MOVD $697, R12 - B callbackasm1(SB) - MOVD $698, R12 - B callbackasm1(SB) - MOVD $699, R12 - B callbackasm1(SB) - MOVD $700, R12 - B callbackasm1(SB) - MOVD $701, R12 - B callbackasm1(SB) - MOVD $702, R12 - B callbackasm1(SB) - MOVD $703, R12 - B callbackasm1(SB) - MOVD $704, R12 - B callbackasm1(SB) - MOVD $705, R12 - B callbackasm1(SB) - MOVD $706, R12 - B callbackasm1(SB) - MOVD $707, R12 - B callbackasm1(SB) - MOVD $708, R12 - B callbackasm1(SB) - MOVD $709, R12 - B callbackasm1(SB) - MOVD $710, R12 - B callbackasm1(SB) - MOVD $711, R12 - B callbackasm1(SB) - MOVD $712, R12 - B callbackasm1(SB) - MOVD $713, R12 - B callbackasm1(SB) - MOVD $714, R12 - B callbackasm1(SB) - MOVD $715, R12 - B callbackasm1(SB) - MOVD $716, R12 - B callbackasm1(SB) - MOVD $717, R12 - B callbackasm1(SB) - MOVD $718, R12 - B callbackasm1(SB) - MOVD $719, R12 - B callbackasm1(SB) - MOVD $720, R12 - B callbackasm1(SB) - MOVD $721, R12 - B callbackasm1(SB) - MOVD $722, R12 - B callbackasm1(SB) - MOVD $723, R12 - B callbackasm1(SB) - MOVD $724, R12 - B callbackasm1(SB) - MOVD $725, R12 - B callbackasm1(SB) - MOVD $726, R12 - B callbackasm1(SB) - MOVD $727, R12 - B callbackasm1(SB) - MOVD $728, R12 - B callbackasm1(SB) - MOVD $729, R12 - B callbackasm1(SB) - MOVD $730, R12 - B callbackasm1(SB) - MOVD $731, R12 - B callbackasm1(SB) - MOVD $732, R12 - B callbackasm1(SB) - MOVD $733, R12 - B callbackasm1(SB) - MOVD $734, R12 - B callbackasm1(SB) - MOVD $735, R12 - B callbackasm1(SB) - MOVD $736, R12 - B callbackasm1(SB) - MOVD $737, R12 - B callbackasm1(SB) - MOVD $738, R12 - B callbackasm1(SB) - MOVD $739, R12 - B callbackasm1(SB) - MOVD $740, R12 - B callbackasm1(SB) - MOVD $741, R12 - B callbackasm1(SB) - MOVD $742, R12 - B callbackasm1(SB) - MOVD $743, R12 - B callbackasm1(SB) - MOVD $744, R12 - B callbackasm1(SB) - MOVD $745, R12 - B callbackasm1(SB) - MOVD $746, R12 - B callbackasm1(SB) - MOVD $747, R12 - B callbackasm1(SB) - MOVD $748, R12 - B callbackasm1(SB) - MOVD $749, R12 - B callbackasm1(SB) - MOVD $750, R12 - B callbackasm1(SB) - MOVD $751, R12 - B callbackasm1(SB) - MOVD $752, R12 - B callbackasm1(SB) - MOVD $753, R12 - B callbackasm1(SB) - MOVD $754, R12 - B callbackasm1(SB) - MOVD $755, R12 - B callbackasm1(SB) - MOVD $756, R12 - B callbackasm1(SB) - MOVD $757, R12 - B callbackasm1(SB) - MOVD $758, R12 - B callbackasm1(SB) - MOVD $759, R12 - B callbackasm1(SB) - MOVD $760, R12 - B callbackasm1(SB) - MOVD $761, R12 - B callbackasm1(SB) - MOVD $762, R12 - B callbackasm1(SB) - MOVD $763, R12 - B callbackasm1(SB) - MOVD $764, R12 - B callbackasm1(SB) - MOVD $765, R12 - B callbackasm1(SB) - MOVD $766, R12 - B callbackasm1(SB) - MOVD $767, R12 - B callbackasm1(SB) - MOVD $768, R12 - B callbackasm1(SB) - MOVD $769, R12 - B callbackasm1(SB) - MOVD $770, R12 - B callbackasm1(SB) - MOVD $771, R12 - B callbackasm1(SB) - MOVD $772, R12 - B callbackasm1(SB) - MOVD $773, R12 - B callbackasm1(SB) - MOVD $774, R12 - B callbackasm1(SB) - MOVD $775, R12 - B callbackasm1(SB) - MOVD $776, R12 - B callbackasm1(SB) - MOVD $777, R12 - B callbackasm1(SB) - MOVD $778, R12 - B callbackasm1(SB) - MOVD $779, R12 - B callbackasm1(SB) - MOVD $780, R12 - B callbackasm1(SB) - MOVD $781, R12 - B callbackasm1(SB) - MOVD $782, R12 - B callbackasm1(SB) - MOVD $783, R12 - B callbackasm1(SB) - MOVD $784, R12 - B callbackasm1(SB) - MOVD $785, R12 - B callbackasm1(SB) - MOVD $786, R12 - B callbackasm1(SB) - MOVD $787, R12 - B callbackasm1(SB) - MOVD $788, R12 - B callbackasm1(SB) - MOVD $789, R12 - B callbackasm1(SB) - MOVD $790, R12 - B callbackasm1(SB) - MOVD $791, R12 - B callbackasm1(SB) - MOVD $792, R12 - B callbackasm1(SB) - MOVD $793, R12 - B callbackasm1(SB) - MOVD $794, R12 - B callbackasm1(SB) - MOVD $795, R12 - B callbackasm1(SB) - MOVD $796, R12 - B callbackasm1(SB) - MOVD $797, R12 - B callbackasm1(SB) - MOVD $798, R12 - B callbackasm1(SB) - MOVD $799, R12 - B callbackasm1(SB) - MOVD $800, R12 - B callbackasm1(SB) - MOVD $801, R12 - B callbackasm1(SB) - MOVD $802, R12 - B callbackasm1(SB) - MOVD $803, R12 - B callbackasm1(SB) - MOVD $804, R12 - B callbackasm1(SB) - MOVD $805, R12 - B callbackasm1(SB) - MOVD $806, R12 - B callbackasm1(SB) - MOVD $807, R12 - B callbackasm1(SB) - MOVD $808, R12 - B callbackasm1(SB) - MOVD $809, R12 - B callbackasm1(SB) - MOVD $810, R12 - B callbackasm1(SB) - MOVD $811, R12 - B callbackasm1(SB) - MOVD $812, R12 - B callbackasm1(SB) - MOVD $813, R12 - B callbackasm1(SB) - MOVD $814, R12 - B callbackasm1(SB) - MOVD $815, R12 - B callbackasm1(SB) - MOVD $816, R12 - B callbackasm1(SB) - MOVD $817, R12 - B callbackasm1(SB) - MOVD $818, R12 - B callbackasm1(SB) - MOVD $819, R12 - B callbackasm1(SB) - MOVD $820, R12 - B callbackasm1(SB) - MOVD $821, R12 - B callbackasm1(SB) - MOVD $822, R12 - B callbackasm1(SB) - MOVD $823, R12 - B callbackasm1(SB) - MOVD $824, R12 - B callbackasm1(SB) - MOVD $825, R12 - B callbackasm1(SB) - MOVD $826, R12 - B callbackasm1(SB) - MOVD $827, R12 - B callbackasm1(SB) - MOVD $828, R12 - B callbackasm1(SB) - MOVD $829, R12 - B callbackasm1(SB) - MOVD $830, R12 - B callbackasm1(SB) - MOVD $831, R12 - B callbackasm1(SB) - MOVD $832, R12 - B callbackasm1(SB) - MOVD $833, R12 - B callbackasm1(SB) - MOVD $834, R12 - B callbackasm1(SB) - MOVD $835, R12 - B callbackasm1(SB) - MOVD $836, R12 - B callbackasm1(SB) - MOVD $837, R12 - B callbackasm1(SB) - MOVD $838, R12 - B callbackasm1(SB) - MOVD $839, R12 - B callbackasm1(SB) - MOVD $840, R12 - B callbackasm1(SB) - MOVD $841, R12 - B callbackasm1(SB) - MOVD $842, R12 - B callbackasm1(SB) - MOVD $843, R12 - B callbackasm1(SB) - MOVD $844, R12 - B callbackasm1(SB) - MOVD $845, R12 - B callbackasm1(SB) - MOVD $846, R12 - B callbackasm1(SB) - MOVD $847, R12 - B callbackasm1(SB) - MOVD $848, R12 - B callbackasm1(SB) - MOVD $849, R12 - B callbackasm1(SB) - MOVD $850, R12 - B callbackasm1(SB) - MOVD $851, R12 - B callbackasm1(SB) - MOVD $852, R12 - B callbackasm1(SB) - MOVD $853, R12 - B callbackasm1(SB) - MOVD $854, R12 - B callbackasm1(SB) - MOVD $855, R12 - B callbackasm1(SB) - MOVD $856, R12 - B callbackasm1(SB) - MOVD $857, R12 - B callbackasm1(SB) - MOVD $858, R12 - B callbackasm1(SB) - MOVD $859, R12 - B callbackasm1(SB) - MOVD $860, R12 - B callbackasm1(SB) - MOVD $861, R12 - B callbackasm1(SB) - MOVD $862, R12 - B callbackasm1(SB) - MOVD $863, R12 - B callbackasm1(SB) - MOVD $864, R12 - B callbackasm1(SB) - MOVD $865, R12 - B callbackasm1(SB) - MOVD $866, R12 - B callbackasm1(SB) - MOVD $867, R12 - B callbackasm1(SB) - MOVD $868, R12 - B callbackasm1(SB) - MOVD $869, R12 - B callbackasm1(SB) - MOVD $870, R12 - B callbackasm1(SB) - MOVD $871, R12 - B callbackasm1(SB) - MOVD $872, R12 - B callbackasm1(SB) - MOVD $873, R12 - B callbackasm1(SB) - MOVD $874, R12 - B callbackasm1(SB) - MOVD $875, R12 - B callbackasm1(SB) - MOVD $876, R12 - B callbackasm1(SB) - MOVD $877, R12 - B callbackasm1(SB) - MOVD $878, R12 - B callbackasm1(SB) - MOVD $879, R12 - B callbackasm1(SB) - MOVD $880, R12 - B callbackasm1(SB) - MOVD $881, R12 - B callbackasm1(SB) - MOVD $882, R12 - B callbackasm1(SB) - MOVD $883, R12 - B callbackasm1(SB) - MOVD $884, R12 - B callbackasm1(SB) - MOVD $885, R12 - B callbackasm1(SB) - MOVD $886, R12 - B callbackasm1(SB) - MOVD $887, R12 - B callbackasm1(SB) - MOVD $888, R12 - B callbackasm1(SB) - MOVD $889, R12 - B callbackasm1(SB) - MOVD $890, R12 - B callbackasm1(SB) - MOVD $891, R12 - B callbackasm1(SB) - MOVD $892, R12 - B callbackasm1(SB) - MOVD $893, R12 - B callbackasm1(SB) - MOVD $894, R12 - B callbackasm1(SB) - MOVD $895, R12 - B callbackasm1(SB) - MOVD $896, R12 - B callbackasm1(SB) - MOVD $897, R12 - B callbackasm1(SB) - MOVD $898, R12 - B callbackasm1(SB) - MOVD $899, R12 - B callbackasm1(SB) - MOVD $900, R12 - B callbackasm1(SB) - MOVD $901, R12 - B callbackasm1(SB) - MOVD $902, R12 - B callbackasm1(SB) - MOVD $903, R12 - B callbackasm1(SB) - MOVD $904, R12 - B callbackasm1(SB) - MOVD $905, R12 - B callbackasm1(SB) - MOVD $906, R12 - B callbackasm1(SB) - MOVD $907, R12 - B callbackasm1(SB) - MOVD $908, R12 - B callbackasm1(SB) - MOVD $909, R12 - B callbackasm1(SB) - MOVD $910, R12 - B callbackasm1(SB) - MOVD $911, R12 - B callbackasm1(SB) - MOVD $912, R12 - B callbackasm1(SB) - MOVD $913, R12 - B callbackasm1(SB) - MOVD $914, R12 - B callbackasm1(SB) - MOVD $915, R12 - B callbackasm1(SB) - MOVD $916, R12 - B callbackasm1(SB) - MOVD $917, R12 - B callbackasm1(SB) - MOVD $918, R12 - B callbackasm1(SB) - MOVD $919, R12 - B callbackasm1(SB) - MOVD $920, R12 - B callbackasm1(SB) - MOVD $921, R12 - B callbackasm1(SB) - MOVD $922, R12 - B callbackasm1(SB) - MOVD $923, R12 - B callbackasm1(SB) - MOVD $924, R12 - B callbackasm1(SB) - MOVD $925, R12 - B callbackasm1(SB) - MOVD $926, R12 - B callbackasm1(SB) - MOVD $927, R12 - B callbackasm1(SB) - MOVD $928, R12 - B callbackasm1(SB) - MOVD $929, R12 - B callbackasm1(SB) - MOVD $930, R12 - B callbackasm1(SB) - MOVD $931, R12 - B callbackasm1(SB) - MOVD $932, R12 - B callbackasm1(SB) - MOVD $933, R12 - B callbackasm1(SB) - MOVD $934, R12 - B callbackasm1(SB) - MOVD $935, R12 - B callbackasm1(SB) - MOVD $936, R12 - B callbackasm1(SB) - MOVD $937, R12 - B callbackasm1(SB) - MOVD $938, R12 - B callbackasm1(SB) - MOVD $939, R12 - B callbackasm1(SB) - MOVD $940, R12 - B callbackasm1(SB) - MOVD $941, R12 - B callbackasm1(SB) - MOVD $942, R12 - B callbackasm1(SB) - MOVD $943, R12 - B callbackasm1(SB) - MOVD $944, R12 - B callbackasm1(SB) - MOVD $945, R12 - B callbackasm1(SB) - MOVD $946, R12 - B callbackasm1(SB) - MOVD $947, R12 - B callbackasm1(SB) - MOVD $948, R12 - B callbackasm1(SB) - MOVD $949, R12 - B callbackasm1(SB) - MOVD $950, R12 - B callbackasm1(SB) - MOVD $951, R12 - B callbackasm1(SB) - MOVD $952, R12 - B callbackasm1(SB) - MOVD $953, R12 - B callbackasm1(SB) - MOVD $954, R12 - B callbackasm1(SB) - MOVD $955, R12 - B callbackasm1(SB) - MOVD $956, R12 - B callbackasm1(SB) - MOVD $957, R12 - B callbackasm1(SB) - MOVD $958, R12 - B callbackasm1(SB) - MOVD $959, R12 - B callbackasm1(SB) - MOVD $960, R12 - B callbackasm1(SB) - MOVD $961, R12 - B callbackasm1(SB) - MOVD $962, R12 - B callbackasm1(SB) - MOVD $963, R12 - B callbackasm1(SB) - MOVD $964, R12 - B callbackasm1(SB) - MOVD $965, R12 - B callbackasm1(SB) - MOVD $966, R12 - B callbackasm1(SB) - MOVD $967, R12 - B callbackasm1(SB) - MOVD $968, R12 - B callbackasm1(SB) - MOVD $969, R12 - B callbackasm1(SB) - MOVD $970, R12 - B callbackasm1(SB) - MOVD $971, R12 - B callbackasm1(SB) - MOVD $972, R12 - B callbackasm1(SB) - MOVD $973, R12 - B callbackasm1(SB) - MOVD $974, R12 - B callbackasm1(SB) - MOVD $975, R12 - B callbackasm1(SB) - MOVD $976, R12 - B callbackasm1(SB) - MOVD $977, R12 - B callbackasm1(SB) - MOVD $978, R12 - B callbackasm1(SB) - MOVD $979, R12 - B callbackasm1(SB) - MOVD $980, R12 - B callbackasm1(SB) - MOVD $981, R12 - B callbackasm1(SB) - MOVD $982, R12 - B callbackasm1(SB) - MOVD $983, R12 - B callbackasm1(SB) - MOVD $984, R12 - B callbackasm1(SB) - MOVD $985, R12 - B callbackasm1(SB) - MOVD $986, R12 - B callbackasm1(SB) - MOVD $987, R12 - B callbackasm1(SB) - MOVD $988, R12 - B callbackasm1(SB) - MOVD $989, R12 - B callbackasm1(SB) - MOVD $990, R12 - B callbackasm1(SB) - MOVD $991, R12 - B callbackasm1(SB) - MOVD $992, R12 - B callbackasm1(SB) - MOVD $993, R12 - B callbackasm1(SB) - MOVD $994, R12 - B callbackasm1(SB) - MOVD $995, R12 - B callbackasm1(SB) - MOVD $996, R12 - B callbackasm1(SB) - MOVD $997, R12 - B callbackasm1(SB) - MOVD $998, R12 - B callbackasm1(SB) - MOVD $999, R12 - B callbackasm1(SB) - MOVD $1000, R12 - B callbackasm1(SB) - MOVD $1001, R12 - B callbackasm1(SB) - MOVD $1002, R12 - B callbackasm1(SB) - MOVD $1003, R12 - B callbackasm1(SB) - MOVD $1004, R12 - B callbackasm1(SB) - MOVD $1005, R12 - B callbackasm1(SB) - MOVD $1006, R12 - B callbackasm1(SB) - MOVD $1007, R12 - B callbackasm1(SB) - MOVD $1008, R12 - B callbackasm1(SB) - MOVD $1009, R12 - B callbackasm1(SB) - MOVD $1010, R12 - B callbackasm1(SB) - MOVD $1011, R12 - B callbackasm1(SB) - MOVD $1012, R12 - B callbackasm1(SB) - MOVD $1013, R12 - B callbackasm1(SB) - MOVD $1014, R12 - B callbackasm1(SB) - MOVD $1015, R12 - B callbackasm1(SB) - MOVD $1016, R12 - B callbackasm1(SB) - MOVD $1017, R12 - B callbackasm1(SB) - MOVD $1018, R12 - B callbackasm1(SB) - MOVD $1019, R12 - B callbackasm1(SB) - MOVD $1020, R12 - B callbackasm1(SB) - MOVD $1021, R12 - B callbackasm1(SB) - MOVD $1022, R12 - B callbackasm1(SB) - MOVD $1023, R12 - B callbackasm1(SB) - MOVD $1024, R12 - B callbackasm1(SB) - MOVD $1025, R12 - B callbackasm1(SB) - MOVD $1026, R12 - B callbackasm1(SB) - MOVD $1027, R12 - B callbackasm1(SB) - MOVD $1028, R12 - B callbackasm1(SB) - MOVD $1029, R12 - B callbackasm1(SB) - MOVD $1030, R12 - B callbackasm1(SB) - MOVD $1031, R12 - B callbackasm1(SB) - MOVD $1032, R12 - B callbackasm1(SB) - MOVD $1033, R12 - B callbackasm1(SB) - MOVD $1034, R12 - B callbackasm1(SB) - MOVD $1035, R12 - B callbackasm1(SB) - MOVD $1036, R12 - B callbackasm1(SB) - MOVD $1037, R12 - B callbackasm1(SB) - MOVD $1038, R12 - B callbackasm1(SB) - MOVD $1039, R12 - B callbackasm1(SB) - MOVD $1040, R12 - B callbackasm1(SB) - MOVD $1041, R12 - B callbackasm1(SB) - MOVD $1042, R12 - B callbackasm1(SB) - MOVD $1043, R12 - B callbackasm1(SB) - MOVD $1044, R12 - B callbackasm1(SB) - MOVD $1045, R12 - B callbackasm1(SB) - MOVD $1046, R12 - B callbackasm1(SB) - MOVD $1047, R12 - B callbackasm1(SB) - MOVD $1048, R12 - B callbackasm1(SB) - MOVD $1049, R12 - B callbackasm1(SB) - MOVD $1050, R12 - B callbackasm1(SB) - MOVD $1051, R12 - B callbackasm1(SB) - MOVD $1052, R12 - B callbackasm1(SB) - MOVD $1053, R12 - B callbackasm1(SB) - MOVD $1054, R12 - B callbackasm1(SB) - MOVD $1055, R12 - B callbackasm1(SB) - MOVD $1056, R12 - B callbackasm1(SB) - MOVD $1057, R12 - B callbackasm1(SB) - MOVD $1058, R12 - B callbackasm1(SB) - MOVD $1059, R12 - B callbackasm1(SB) - MOVD $1060, R12 - B callbackasm1(SB) - MOVD $1061, R12 - B callbackasm1(SB) - MOVD $1062, R12 - B callbackasm1(SB) - MOVD $1063, R12 - B callbackasm1(SB) - MOVD $1064, R12 - B callbackasm1(SB) - MOVD $1065, R12 - B callbackasm1(SB) - MOVD $1066, R12 - B callbackasm1(SB) - MOVD $1067, R12 - B callbackasm1(SB) - MOVD $1068, R12 - B callbackasm1(SB) - MOVD $1069, R12 - B callbackasm1(SB) - MOVD $1070, R12 - B callbackasm1(SB) - MOVD $1071, R12 - B callbackasm1(SB) - MOVD $1072, R12 - B callbackasm1(SB) - MOVD $1073, R12 - B callbackasm1(SB) - MOVD $1074, R12 - B callbackasm1(SB) - MOVD $1075, R12 - B callbackasm1(SB) - MOVD $1076, R12 - B callbackasm1(SB) - MOVD $1077, R12 - B callbackasm1(SB) - MOVD $1078, R12 - B callbackasm1(SB) - MOVD $1079, R12 - B callbackasm1(SB) - MOVD $1080, R12 - B callbackasm1(SB) - MOVD $1081, R12 - B callbackasm1(SB) - MOVD $1082, R12 - B callbackasm1(SB) - MOVD $1083, R12 - B callbackasm1(SB) - MOVD $1084, R12 - B callbackasm1(SB) - MOVD $1085, R12 - B callbackasm1(SB) - MOVD $1086, R12 - B callbackasm1(SB) - MOVD $1087, R12 - B callbackasm1(SB) - MOVD $1088, R12 - B callbackasm1(SB) - MOVD $1089, R12 - B callbackasm1(SB) - MOVD $1090, R12 - B callbackasm1(SB) - MOVD $1091, R12 - B callbackasm1(SB) - MOVD $1092, R12 - B callbackasm1(SB) - MOVD $1093, R12 - B callbackasm1(SB) - MOVD $1094, R12 - B callbackasm1(SB) - MOVD $1095, R12 - B callbackasm1(SB) - MOVD $1096, R12 - B callbackasm1(SB) - MOVD $1097, R12 - B callbackasm1(SB) - MOVD $1098, R12 - B callbackasm1(SB) - MOVD $1099, R12 - B callbackasm1(SB) - MOVD $1100, R12 - B callbackasm1(SB) - MOVD $1101, R12 - B callbackasm1(SB) - MOVD $1102, R12 - B callbackasm1(SB) - MOVD $1103, R12 - B callbackasm1(SB) - MOVD $1104, R12 - B callbackasm1(SB) - MOVD $1105, R12 - B callbackasm1(SB) - MOVD $1106, R12 - B callbackasm1(SB) - MOVD $1107, R12 - B callbackasm1(SB) - MOVD $1108, R12 - B callbackasm1(SB) - MOVD $1109, R12 - B callbackasm1(SB) - MOVD $1110, R12 - B callbackasm1(SB) - MOVD $1111, R12 - B callbackasm1(SB) - MOVD $1112, R12 - B callbackasm1(SB) - MOVD $1113, R12 - B callbackasm1(SB) - MOVD $1114, R12 - B callbackasm1(SB) - MOVD $1115, R12 - B callbackasm1(SB) - MOVD $1116, R12 - B callbackasm1(SB) - MOVD $1117, R12 - B callbackasm1(SB) - MOVD $1118, R12 - B callbackasm1(SB) - MOVD $1119, R12 - B callbackasm1(SB) - MOVD $1120, R12 - B callbackasm1(SB) - MOVD $1121, R12 - B callbackasm1(SB) - MOVD $1122, R12 - B callbackasm1(SB) - MOVD $1123, R12 - B callbackasm1(SB) - MOVD $1124, R12 - B callbackasm1(SB) - MOVD $1125, R12 - B callbackasm1(SB) - MOVD $1126, R12 - B callbackasm1(SB) - MOVD $1127, R12 - B callbackasm1(SB) - MOVD $1128, R12 - B callbackasm1(SB) - MOVD $1129, R12 - B callbackasm1(SB) - MOVD $1130, R12 - B callbackasm1(SB) - MOVD $1131, R12 - B callbackasm1(SB) - MOVD $1132, R12 - B callbackasm1(SB) - MOVD $1133, R12 - B callbackasm1(SB) - MOVD $1134, R12 - B callbackasm1(SB) - MOVD $1135, R12 - B callbackasm1(SB) - MOVD $1136, R12 - B callbackasm1(SB) - MOVD $1137, R12 - B callbackasm1(SB) - MOVD $1138, R12 - B callbackasm1(SB) - MOVD $1139, R12 - B callbackasm1(SB) - MOVD $1140, R12 - B callbackasm1(SB) - MOVD $1141, R12 - B callbackasm1(SB) - MOVD $1142, R12 - B callbackasm1(SB) - MOVD $1143, R12 - B callbackasm1(SB) - MOVD $1144, R12 - B callbackasm1(SB) - MOVD $1145, R12 - B callbackasm1(SB) - MOVD $1146, R12 - B callbackasm1(SB) - MOVD $1147, R12 - B callbackasm1(SB) - MOVD $1148, R12 - B callbackasm1(SB) - MOVD $1149, R12 - B callbackasm1(SB) - MOVD $1150, R12 - B callbackasm1(SB) - MOVD $1151, R12 - B callbackasm1(SB) - MOVD $1152, R12 - B callbackasm1(SB) - MOVD $1153, R12 - B callbackasm1(SB) - MOVD $1154, R12 - B callbackasm1(SB) - MOVD $1155, R12 - B callbackasm1(SB) - MOVD $1156, R12 - B callbackasm1(SB) - MOVD $1157, R12 - B callbackasm1(SB) - MOVD $1158, R12 - B callbackasm1(SB) - MOVD $1159, R12 - B callbackasm1(SB) - MOVD $1160, R12 - B callbackasm1(SB) - MOVD $1161, R12 - B callbackasm1(SB) - MOVD $1162, R12 - B callbackasm1(SB) - MOVD $1163, R12 - B callbackasm1(SB) - MOVD $1164, R12 - B callbackasm1(SB) - MOVD $1165, R12 - B callbackasm1(SB) - MOVD $1166, R12 - B callbackasm1(SB) - MOVD $1167, R12 - B callbackasm1(SB) - MOVD $1168, R12 - B callbackasm1(SB) - MOVD $1169, R12 - B callbackasm1(SB) - MOVD $1170, R12 - B callbackasm1(SB) - MOVD $1171, R12 - B callbackasm1(SB) - MOVD $1172, R12 - B callbackasm1(SB) - MOVD $1173, R12 - B callbackasm1(SB) - MOVD $1174, R12 - B callbackasm1(SB) - MOVD $1175, R12 - B callbackasm1(SB) - MOVD $1176, R12 - B callbackasm1(SB) - MOVD $1177, R12 - B callbackasm1(SB) - MOVD $1178, R12 - B callbackasm1(SB) - MOVD $1179, R12 - B callbackasm1(SB) - MOVD $1180, R12 - B callbackasm1(SB) - MOVD $1181, R12 - B callbackasm1(SB) - MOVD $1182, R12 - B callbackasm1(SB) - MOVD $1183, R12 - B callbackasm1(SB) - MOVD $1184, R12 - B callbackasm1(SB) - MOVD $1185, R12 - B callbackasm1(SB) - MOVD $1186, R12 - B callbackasm1(SB) - MOVD $1187, R12 - B callbackasm1(SB) - MOVD $1188, R12 - B callbackasm1(SB) - MOVD $1189, R12 - B callbackasm1(SB) - MOVD $1190, R12 - B callbackasm1(SB) - MOVD $1191, R12 - B callbackasm1(SB) - MOVD $1192, R12 - B callbackasm1(SB) - MOVD $1193, R12 - B callbackasm1(SB) - MOVD $1194, R12 - B callbackasm1(SB) - MOVD $1195, R12 - B callbackasm1(SB) - MOVD $1196, R12 - B callbackasm1(SB) - MOVD $1197, R12 - B callbackasm1(SB) - MOVD $1198, R12 - B callbackasm1(SB) - MOVD $1199, R12 - B callbackasm1(SB) - MOVD $1200, R12 - B callbackasm1(SB) - MOVD $1201, R12 - B callbackasm1(SB) - MOVD $1202, R12 - B callbackasm1(SB) - MOVD $1203, R12 - B callbackasm1(SB) - MOVD $1204, R12 - B callbackasm1(SB) - MOVD $1205, R12 - B callbackasm1(SB) - MOVD $1206, R12 - B callbackasm1(SB) - MOVD $1207, R12 - B callbackasm1(SB) - MOVD $1208, R12 - B callbackasm1(SB) - MOVD $1209, R12 - B callbackasm1(SB) - MOVD $1210, R12 - B callbackasm1(SB) - MOVD $1211, R12 - B callbackasm1(SB) - MOVD $1212, R12 - B callbackasm1(SB) - MOVD $1213, R12 - B callbackasm1(SB) - MOVD $1214, R12 - B callbackasm1(SB) - MOVD $1215, R12 - B callbackasm1(SB) - MOVD $1216, R12 - B callbackasm1(SB) - MOVD $1217, R12 - B callbackasm1(SB) - MOVD $1218, R12 - B callbackasm1(SB) - MOVD $1219, R12 - B callbackasm1(SB) - MOVD $1220, R12 - B callbackasm1(SB) - MOVD $1221, R12 - B callbackasm1(SB) - MOVD $1222, R12 - B callbackasm1(SB) - MOVD $1223, R12 - B callbackasm1(SB) - MOVD $1224, R12 - B callbackasm1(SB) - MOVD $1225, R12 - B callbackasm1(SB) - MOVD $1226, R12 - B callbackasm1(SB) - MOVD $1227, R12 - B callbackasm1(SB) - MOVD $1228, R12 - B callbackasm1(SB) - MOVD $1229, R12 - B callbackasm1(SB) - MOVD $1230, R12 - B callbackasm1(SB) - MOVD $1231, R12 - B callbackasm1(SB) - MOVD $1232, R12 - B callbackasm1(SB) - MOVD $1233, R12 - B callbackasm1(SB) - MOVD $1234, R12 - B callbackasm1(SB) - MOVD $1235, R12 - B callbackasm1(SB) - MOVD $1236, R12 - B callbackasm1(SB) - MOVD $1237, R12 - B callbackasm1(SB) - MOVD $1238, R12 - B callbackasm1(SB) - MOVD $1239, R12 - B callbackasm1(SB) - MOVD $1240, R12 - B callbackasm1(SB) - MOVD $1241, R12 - B callbackasm1(SB) - MOVD $1242, R12 - B callbackasm1(SB) - MOVD $1243, R12 - B callbackasm1(SB) - MOVD $1244, R12 - B callbackasm1(SB) - MOVD $1245, R12 - B callbackasm1(SB) - MOVD $1246, R12 - B callbackasm1(SB) - MOVD $1247, R12 - B callbackasm1(SB) - MOVD $1248, R12 - B callbackasm1(SB) - MOVD $1249, R12 - B callbackasm1(SB) - MOVD $1250, R12 - B callbackasm1(SB) - MOVD $1251, R12 - B callbackasm1(SB) - MOVD $1252, R12 - B callbackasm1(SB) - MOVD $1253, R12 - B callbackasm1(SB) - MOVD $1254, R12 - B callbackasm1(SB) - MOVD $1255, R12 - B callbackasm1(SB) - MOVD $1256, R12 - B callbackasm1(SB) - MOVD $1257, R12 - B callbackasm1(SB) - MOVD $1258, R12 - B callbackasm1(SB) - MOVD $1259, R12 - B callbackasm1(SB) - MOVD $1260, R12 - B callbackasm1(SB) - MOVD $1261, R12 - B callbackasm1(SB) - MOVD $1262, R12 - B callbackasm1(SB) - MOVD $1263, R12 - B callbackasm1(SB) - MOVD $1264, R12 - B callbackasm1(SB) - MOVD $1265, R12 - B callbackasm1(SB) - MOVD $1266, R12 - B callbackasm1(SB) - MOVD $1267, R12 - B callbackasm1(SB) - MOVD $1268, R12 - B callbackasm1(SB) - MOVD $1269, R12 - B callbackasm1(SB) - MOVD $1270, R12 - B callbackasm1(SB) - MOVD $1271, R12 - B callbackasm1(SB) - MOVD $1272, R12 - B callbackasm1(SB) - MOVD $1273, R12 - B callbackasm1(SB) - MOVD $1274, R12 - B callbackasm1(SB) - MOVD $1275, R12 - B callbackasm1(SB) - MOVD $1276, R12 - B callbackasm1(SB) - MOVD $1277, R12 - B callbackasm1(SB) - MOVD $1278, R12 - B callbackasm1(SB) - MOVD $1279, R12 - B callbackasm1(SB) - MOVD $1280, R12 - B callbackasm1(SB) - MOVD $1281, R12 - B callbackasm1(SB) - MOVD $1282, R12 - B callbackasm1(SB) - MOVD $1283, R12 - B callbackasm1(SB) - MOVD $1284, R12 - B callbackasm1(SB) - MOVD $1285, R12 - B callbackasm1(SB) - MOVD $1286, R12 - B callbackasm1(SB) - MOVD $1287, R12 - B callbackasm1(SB) - MOVD $1288, R12 - B callbackasm1(SB) - MOVD $1289, R12 - B callbackasm1(SB) - MOVD $1290, R12 - B callbackasm1(SB) - MOVD $1291, R12 - B callbackasm1(SB) - MOVD $1292, R12 - B callbackasm1(SB) - MOVD $1293, R12 - B callbackasm1(SB) - MOVD $1294, R12 - B callbackasm1(SB) - MOVD $1295, R12 - B callbackasm1(SB) - MOVD $1296, R12 - B callbackasm1(SB) - MOVD $1297, R12 - B callbackasm1(SB) - MOVD $1298, R12 - B callbackasm1(SB) - MOVD $1299, R12 - B callbackasm1(SB) - MOVD $1300, R12 - B callbackasm1(SB) - MOVD $1301, R12 - B callbackasm1(SB) - MOVD $1302, R12 - B callbackasm1(SB) - MOVD $1303, R12 - B callbackasm1(SB) - MOVD $1304, R12 - B callbackasm1(SB) - MOVD $1305, R12 - B callbackasm1(SB) - MOVD $1306, R12 - B callbackasm1(SB) - MOVD $1307, R12 - B callbackasm1(SB) - MOVD $1308, R12 - B callbackasm1(SB) - MOVD $1309, R12 - B callbackasm1(SB) - MOVD $1310, R12 - B callbackasm1(SB) - MOVD $1311, R12 - B callbackasm1(SB) - MOVD $1312, R12 - B callbackasm1(SB) - MOVD $1313, R12 - B callbackasm1(SB) - MOVD $1314, R12 - B callbackasm1(SB) - MOVD $1315, R12 - B callbackasm1(SB) - MOVD $1316, R12 - B callbackasm1(SB) - MOVD $1317, R12 - B callbackasm1(SB) - MOVD $1318, R12 - B callbackasm1(SB) - MOVD $1319, R12 - B callbackasm1(SB) - MOVD $1320, R12 - B callbackasm1(SB) - MOVD $1321, R12 - B callbackasm1(SB) - MOVD $1322, R12 - B callbackasm1(SB) - MOVD $1323, R12 - B callbackasm1(SB) - MOVD $1324, R12 - B callbackasm1(SB) - MOVD $1325, R12 - B callbackasm1(SB) - MOVD $1326, R12 - B callbackasm1(SB) - MOVD $1327, R12 - B callbackasm1(SB) - MOVD $1328, R12 - B callbackasm1(SB) - MOVD $1329, R12 - B callbackasm1(SB) - MOVD $1330, R12 - B callbackasm1(SB) - MOVD $1331, R12 - B callbackasm1(SB) - MOVD $1332, R12 - B callbackasm1(SB) - MOVD $1333, R12 - B callbackasm1(SB) - MOVD $1334, R12 - B callbackasm1(SB) - MOVD $1335, R12 - B callbackasm1(SB) - MOVD $1336, R12 - B callbackasm1(SB) - MOVD $1337, R12 - B callbackasm1(SB) - MOVD $1338, R12 - B callbackasm1(SB) - MOVD $1339, R12 - B callbackasm1(SB) - MOVD $1340, R12 - B callbackasm1(SB) - MOVD $1341, R12 - B callbackasm1(SB) - MOVD $1342, R12 - B callbackasm1(SB) - MOVD $1343, R12 - B callbackasm1(SB) - MOVD $1344, R12 - B callbackasm1(SB) - MOVD $1345, R12 - B callbackasm1(SB) - MOVD $1346, R12 - B callbackasm1(SB) - MOVD $1347, R12 - B callbackasm1(SB) - MOVD $1348, R12 - B callbackasm1(SB) - MOVD $1349, R12 - B callbackasm1(SB) - MOVD $1350, R12 - B callbackasm1(SB) - MOVD $1351, R12 - B callbackasm1(SB) - MOVD $1352, R12 - B callbackasm1(SB) - MOVD $1353, R12 - B callbackasm1(SB) - MOVD $1354, R12 - B callbackasm1(SB) - MOVD $1355, R12 - B callbackasm1(SB) - MOVD $1356, R12 - B callbackasm1(SB) - MOVD $1357, R12 - B callbackasm1(SB) - MOVD $1358, R12 - B callbackasm1(SB) - MOVD $1359, R12 - B callbackasm1(SB) - MOVD $1360, R12 - B callbackasm1(SB) - MOVD $1361, R12 - B callbackasm1(SB) - MOVD $1362, R12 - B callbackasm1(SB) - MOVD $1363, R12 - B callbackasm1(SB) - MOVD $1364, R12 - B callbackasm1(SB) - MOVD $1365, R12 - B callbackasm1(SB) - MOVD $1366, R12 - B callbackasm1(SB) - MOVD $1367, R12 - B callbackasm1(SB) - MOVD $1368, R12 - B callbackasm1(SB) - MOVD $1369, R12 - B callbackasm1(SB) - MOVD $1370, R12 - B callbackasm1(SB) - MOVD $1371, R12 - B callbackasm1(SB) - MOVD $1372, R12 - B callbackasm1(SB) - MOVD $1373, R12 - B callbackasm1(SB) - MOVD $1374, R12 - B callbackasm1(SB) - MOVD $1375, R12 - B callbackasm1(SB) - MOVD $1376, R12 - B callbackasm1(SB) - MOVD $1377, R12 - B callbackasm1(SB) - MOVD $1378, R12 - B callbackasm1(SB) - MOVD $1379, R12 - B callbackasm1(SB) - MOVD $1380, R12 - B callbackasm1(SB) - MOVD $1381, R12 - B callbackasm1(SB) - MOVD $1382, R12 - B callbackasm1(SB) - MOVD $1383, R12 - B callbackasm1(SB) - MOVD $1384, R12 - B callbackasm1(SB) - MOVD $1385, R12 - B callbackasm1(SB) - MOVD $1386, R12 - B callbackasm1(SB) - MOVD $1387, R12 - B callbackasm1(SB) - MOVD $1388, R12 - B callbackasm1(SB) - MOVD $1389, R12 - B callbackasm1(SB) - MOVD $1390, R12 - B callbackasm1(SB) - MOVD $1391, R12 - B callbackasm1(SB) - MOVD $1392, R12 - B callbackasm1(SB) - MOVD $1393, R12 - B callbackasm1(SB) - MOVD $1394, R12 - B callbackasm1(SB) - MOVD $1395, R12 - B callbackasm1(SB) - MOVD $1396, R12 - B callbackasm1(SB) - MOVD $1397, R12 - B callbackasm1(SB) - MOVD $1398, R12 - B callbackasm1(SB) - MOVD $1399, R12 - B callbackasm1(SB) - MOVD $1400, R12 - B callbackasm1(SB) - MOVD $1401, R12 - B callbackasm1(SB) - MOVD $1402, R12 - B callbackasm1(SB) - MOVD $1403, R12 - B callbackasm1(SB) - MOVD $1404, R12 - B callbackasm1(SB) - MOVD $1405, R12 - B callbackasm1(SB) - MOVD $1406, R12 - B callbackasm1(SB) - MOVD $1407, R12 - B callbackasm1(SB) - MOVD $1408, R12 - B callbackasm1(SB) - MOVD $1409, R12 - B callbackasm1(SB) - MOVD $1410, R12 - B callbackasm1(SB) - MOVD $1411, R12 - B callbackasm1(SB) - MOVD $1412, R12 - B callbackasm1(SB) - MOVD $1413, R12 - B callbackasm1(SB) - MOVD $1414, R12 - B callbackasm1(SB) - MOVD $1415, R12 - B callbackasm1(SB) - MOVD $1416, R12 - B callbackasm1(SB) - MOVD $1417, R12 - B callbackasm1(SB) - MOVD $1418, R12 - B callbackasm1(SB) - MOVD $1419, R12 - B callbackasm1(SB) - MOVD $1420, R12 - B callbackasm1(SB) - MOVD $1421, R12 - B callbackasm1(SB) - MOVD $1422, R12 - B callbackasm1(SB) - MOVD $1423, R12 - B callbackasm1(SB) - MOVD $1424, R12 - B callbackasm1(SB) - MOVD $1425, R12 - B callbackasm1(SB) - MOVD $1426, R12 - B callbackasm1(SB) - MOVD $1427, R12 - B callbackasm1(SB) - MOVD $1428, R12 - B callbackasm1(SB) - MOVD $1429, R12 - B callbackasm1(SB) - MOVD $1430, R12 - B callbackasm1(SB) - MOVD $1431, R12 - B callbackasm1(SB) - MOVD $1432, R12 - B callbackasm1(SB) - MOVD $1433, R12 - B callbackasm1(SB) - MOVD $1434, R12 - B callbackasm1(SB) - MOVD $1435, R12 - B callbackasm1(SB) - MOVD $1436, R12 - B callbackasm1(SB) - MOVD $1437, R12 - B callbackasm1(SB) - MOVD $1438, R12 - B callbackasm1(SB) - MOVD $1439, R12 - B callbackasm1(SB) - MOVD $1440, R12 - B callbackasm1(SB) - MOVD $1441, R12 - B callbackasm1(SB) - MOVD $1442, R12 - B callbackasm1(SB) - MOVD $1443, R12 - B callbackasm1(SB) - MOVD $1444, R12 - B callbackasm1(SB) - MOVD $1445, R12 - B callbackasm1(SB) - MOVD $1446, R12 - B callbackasm1(SB) - MOVD $1447, R12 - B callbackasm1(SB) - MOVD $1448, R12 - B callbackasm1(SB) - MOVD $1449, R12 - B callbackasm1(SB) - MOVD $1450, R12 - B callbackasm1(SB) - MOVD $1451, R12 - B callbackasm1(SB) - MOVD $1452, R12 - B callbackasm1(SB) - MOVD $1453, R12 - B callbackasm1(SB) - MOVD $1454, R12 - B callbackasm1(SB) - MOVD $1455, R12 - B callbackasm1(SB) - MOVD $1456, R12 - B callbackasm1(SB) - MOVD $1457, R12 - B callbackasm1(SB) - MOVD $1458, R12 - B callbackasm1(SB) - MOVD $1459, R12 - B callbackasm1(SB) - MOVD $1460, R12 - B callbackasm1(SB) - MOVD $1461, R12 - B callbackasm1(SB) - MOVD $1462, R12 - B callbackasm1(SB) - MOVD $1463, R12 - B callbackasm1(SB) - MOVD $1464, R12 - B callbackasm1(SB) - MOVD $1465, R12 - B callbackasm1(SB) - MOVD $1466, R12 - B callbackasm1(SB) - MOVD $1467, R12 - B callbackasm1(SB) - MOVD $1468, R12 - B callbackasm1(SB) - MOVD $1469, R12 - B callbackasm1(SB) - MOVD $1470, R12 - B callbackasm1(SB) - MOVD $1471, R12 - B callbackasm1(SB) - MOVD $1472, R12 - B callbackasm1(SB) - MOVD $1473, R12 - B callbackasm1(SB) - MOVD $1474, R12 - B callbackasm1(SB) - MOVD $1475, R12 - B callbackasm1(SB) - MOVD $1476, R12 - B callbackasm1(SB) - MOVD $1477, R12 - B callbackasm1(SB) - MOVD $1478, R12 - B callbackasm1(SB) - MOVD $1479, R12 - B callbackasm1(SB) - MOVD $1480, R12 - B callbackasm1(SB) - MOVD $1481, R12 - B callbackasm1(SB) - MOVD $1482, R12 - B callbackasm1(SB) - MOVD $1483, R12 - B callbackasm1(SB) - MOVD $1484, R12 - B callbackasm1(SB) - MOVD $1485, R12 - B callbackasm1(SB) - MOVD $1486, R12 - B callbackasm1(SB) - MOVD $1487, R12 - B callbackasm1(SB) - MOVD $1488, R12 - B callbackasm1(SB) - MOVD $1489, R12 - B callbackasm1(SB) - MOVD $1490, R12 - B callbackasm1(SB) - MOVD $1491, R12 - B callbackasm1(SB) - MOVD $1492, R12 - B callbackasm1(SB) - MOVD $1493, R12 - B callbackasm1(SB) - MOVD $1494, R12 - B callbackasm1(SB) - MOVD $1495, R12 - B callbackasm1(SB) - MOVD $1496, R12 - B callbackasm1(SB) - MOVD $1497, R12 - B callbackasm1(SB) - MOVD $1498, R12 - B callbackasm1(SB) - MOVD $1499, R12 - B callbackasm1(SB) - MOVD $1500, R12 - B callbackasm1(SB) - MOVD $1501, R12 - B callbackasm1(SB) - MOVD $1502, R12 - B callbackasm1(SB) - MOVD $1503, R12 - B callbackasm1(SB) - MOVD $1504, R12 - B callbackasm1(SB) - MOVD $1505, R12 - B callbackasm1(SB) - MOVD $1506, R12 - B callbackasm1(SB) - MOVD $1507, R12 - B callbackasm1(SB) - MOVD $1508, R12 - B callbackasm1(SB) - MOVD $1509, R12 - B callbackasm1(SB) - MOVD $1510, R12 - B callbackasm1(SB) - MOVD $1511, R12 - B callbackasm1(SB) - MOVD $1512, R12 - B callbackasm1(SB) - MOVD $1513, R12 - B callbackasm1(SB) - MOVD $1514, R12 - B callbackasm1(SB) - MOVD $1515, R12 - B callbackasm1(SB) - MOVD $1516, R12 - B callbackasm1(SB) - MOVD $1517, R12 - B callbackasm1(SB) - MOVD $1518, R12 - B callbackasm1(SB) - MOVD $1519, R12 - B callbackasm1(SB) - MOVD $1520, R12 - B callbackasm1(SB) - MOVD $1521, R12 - B callbackasm1(SB) - MOVD $1522, R12 - B callbackasm1(SB) - MOVD $1523, R12 - B callbackasm1(SB) - MOVD $1524, R12 - B callbackasm1(SB) - MOVD $1525, R12 - B callbackasm1(SB) - MOVD $1526, R12 - B callbackasm1(SB) - MOVD $1527, R12 - B callbackasm1(SB) - MOVD $1528, R12 - B callbackasm1(SB) - MOVD $1529, R12 - B callbackasm1(SB) - MOVD $1530, R12 - B callbackasm1(SB) - MOVD $1531, R12 - B callbackasm1(SB) - MOVD $1532, R12 - B callbackasm1(SB) - MOVD $1533, R12 - B callbackasm1(SB) - MOVD $1534, R12 - B callbackasm1(SB) - MOVD $1535, R12 - B callbackasm1(SB) - MOVD $1536, R12 - B callbackasm1(SB) - MOVD $1537, R12 - B callbackasm1(SB) - MOVD $1538, R12 - B callbackasm1(SB) - MOVD $1539, R12 - B callbackasm1(SB) - MOVD $1540, R12 - B callbackasm1(SB) - MOVD $1541, R12 - B callbackasm1(SB) - MOVD $1542, R12 - B callbackasm1(SB) - MOVD $1543, R12 - B callbackasm1(SB) - MOVD $1544, R12 - B callbackasm1(SB) - MOVD $1545, R12 - B callbackasm1(SB) - MOVD $1546, R12 - B callbackasm1(SB) - MOVD $1547, R12 - B callbackasm1(SB) - MOVD $1548, R12 - B callbackasm1(SB) - MOVD $1549, R12 - B callbackasm1(SB) - MOVD $1550, R12 - B callbackasm1(SB) - MOVD $1551, R12 - B callbackasm1(SB) - MOVD $1552, R12 - B callbackasm1(SB) - MOVD $1553, R12 - B callbackasm1(SB) - MOVD $1554, R12 - B callbackasm1(SB) - MOVD $1555, R12 - B callbackasm1(SB) - MOVD $1556, R12 - B callbackasm1(SB) - MOVD $1557, R12 - B callbackasm1(SB) - MOVD $1558, R12 - B callbackasm1(SB) - MOVD $1559, R12 - B callbackasm1(SB) - MOVD $1560, R12 - B callbackasm1(SB) - MOVD $1561, R12 - B callbackasm1(SB) - MOVD $1562, R12 - B callbackasm1(SB) - MOVD $1563, R12 - B callbackasm1(SB) - MOVD $1564, R12 - B callbackasm1(SB) - MOVD $1565, R12 - B callbackasm1(SB) - MOVD $1566, R12 - B callbackasm1(SB) - MOVD $1567, R12 - B callbackasm1(SB) - MOVD $1568, R12 - B callbackasm1(SB) - MOVD $1569, R12 - B callbackasm1(SB) - MOVD $1570, R12 - B callbackasm1(SB) - MOVD $1571, R12 - B callbackasm1(SB) - MOVD $1572, R12 - B callbackasm1(SB) - MOVD $1573, R12 - B callbackasm1(SB) - MOVD $1574, R12 - B callbackasm1(SB) - MOVD $1575, R12 - B callbackasm1(SB) - MOVD $1576, R12 - B callbackasm1(SB) - MOVD $1577, R12 - B callbackasm1(SB) - MOVD $1578, R12 - B callbackasm1(SB) - MOVD $1579, R12 - B callbackasm1(SB) - MOVD $1580, R12 - B callbackasm1(SB) - MOVD $1581, R12 - B callbackasm1(SB) - MOVD $1582, R12 - B callbackasm1(SB) - MOVD $1583, R12 - B callbackasm1(SB) - MOVD $1584, R12 - B callbackasm1(SB) - MOVD $1585, R12 - B callbackasm1(SB) - MOVD $1586, R12 - B callbackasm1(SB) - MOVD $1587, R12 - B callbackasm1(SB) - MOVD $1588, R12 - B callbackasm1(SB) - MOVD $1589, R12 - B callbackasm1(SB) - MOVD $1590, R12 - B callbackasm1(SB) - MOVD $1591, R12 - B callbackasm1(SB) - MOVD $1592, R12 - B callbackasm1(SB) - MOVD $1593, R12 - B callbackasm1(SB) - MOVD $1594, R12 - B callbackasm1(SB) - MOVD $1595, R12 - B callbackasm1(SB) - MOVD $1596, R12 - B callbackasm1(SB) - MOVD $1597, R12 - B callbackasm1(SB) - MOVD $1598, R12 - B callbackasm1(SB) - MOVD $1599, R12 - B callbackasm1(SB) - MOVD $1600, R12 - B callbackasm1(SB) - MOVD $1601, R12 - B callbackasm1(SB) - MOVD $1602, R12 - B callbackasm1(SB) - MOVD $1603, R12 - B callbackasm1(SB) - MOVD $1604, R12 - B callbackasm1(SB) - MOVD $1605, R12 - B callbackasm1(SB) - MOVD $1606, R12 - B callbackasm1(SB) - MOVD $1607, R12 - B callbackasm1(SB) - MOVD $1608, R12 - B callbackasm1(SB) - MOVD $1609, R12 - B callbackasm1(SB) - MOVD $1610, R12 - B callbackasm1(SB) - MOVD $1611, R12 - B callbackasm1(SB) - MOVD $1612, R12 - B callbackasm1(SB) - MOVD $1613, R12 - B callbackasm1(SB) - MOVD $1614, R12 - B callbackasm1(SB) - MOVD $1615, R12 - B callbackasm1(SB) - MOVD $1616, R12 - B callbackasm1(SB) - MOVD $1617, R12 - B callbackasm1(SB) - MOVD $1618, R12 - B callbackasm1(SB) - MOVD $1619, R12 - B callbackasm1(SB) - MOVD $1620, R12 - B callbackasm1(SB) - MOVD $1621, R12 - B callbackasm1(SB) - MOVD $1622, R12 - B callbackasm1(SB) - MOVD $1623, R12 - B callbackasm1(SB) - MOVD $1624, R12 - B callbackasm1(SB) - MOVD $1625, R12 - B callbackasm1(SB) - MOVD $1626, R12 - B callbackasm1(SB) - MOVD $1627, R12 - B callbackasm1(SB) - MOVD $1628, R12 - B callbackasm1(SB) - MOVD $1629, R12 - B callbackasm1(SB) - MOVD $1630, R12 - B callbackasm1(SB) - MOVD $1631, R12 - B callbackasm1(SB) - MOVD $1632, R12 - B callbackasm1(SB) - MOVD $1633, R12 - B callbackasm1(SB) - MOVD $1634, R12 - B callbackasm1(SB) - MOVD $1635, R12 - B callbackasm1(SB) - MOVD $1636, R12 - B callbackasm1(SB) - MOVD $1637, R12 - B callbackasm1(SB) - MOVD $1638, R12 - B callbackasm1(SB) - MOVD $1639, R12 - B callbackasm1(SB) - MOVD $1640, R12 - B callbackasm1(SB) - MOVD $1641, R12 - B callbackasm1(SB) - MOVD $1642, R12 - B callbackasm1(SB) - MOVD $1643, R12 - B callbackasm1(SB) - MOVD $1644, R12 - B callbackasm1(SB) - MOVD $1645, R12 - B callbackasm1(SB) - MOVD $1646, R12 - B callbackasm1(SB) - MOVD $1647, R12 - B callbackasm1(SB) - MOVD $1648, R12 - B callbackasm1(SB) - MOVD $1649, R12 - B callbackasm1(SB) - MOVD $1650, R12 - B callbackasm1(SB) - MOVD $1651, R12 - B callbackasm1(SB) - MOVD $1652, R12 - B callbackasm1(SB) - MOVD $1653, R12 - B callbackasm1(SB) - MOVD $1654, R12 - B callbackasm1(SB) - MOVD $1655, R12 - B callbackasm1(SB) - MOVD $1656, R12 - B callbackasm1(SB) - MOVD $1657, R12 - B callbackasm1(SB) - MOVD $1658, R12 - B callbackasm1(SB) - MOVD $1659, R12 - B callbackasm1(SB) - MOVD $1660, R12 - B callbackasm1(SB) - MOVD $1661, R12 - B callbackasm1(SB) - MOVD $1662, R12 - B callbackasm1(SB) - MOVD $1663, R12 - B callbackasm1(SB) - MOVD $1664, R12 - B callbackasm1(SB) - MOVD $1665, R12 - B callbackasm1(SB) - MOVD $1666, R12 - B callbackasm1(SB) - MOVD $1667, R12 - B callbackasm1(SB) - MOVD $1668, R12 - B callbackasm1(SB) - MOVD $1669, R12 - B callbackasm1(SB) - MOVD $1670, R12 - B callbackasm1(SB) - MOVD $1671, R12 - B callbackasm1(SB) - MOVD $1672, R12 - B callbackasm1(SB) - MOVD $1673, R12 - B callbackasm1(SB) - MOVD $1674, R12 - B callbackasm1(SB) - MOVD $1675, R12 - B callbackasm1(SB) - MOVD $1676, R12 - B callbackasm1(SB) - MOVD $1677, R12 - B callbackasm1(SB) - MOVD $1678, R12 - B callbackasm1(SB) - MOVD $1679, R12 - B callbackasm1(SB) - MOVD $1680, R12 - B callbackasm1(SB) - MOVD $1681, R12 - B callbackasm1(SB) - MOVD $1682, R12 - B callbackasm1(SB) - MOVD $1683, R12 - B callbackasm1(SB) - MOVD $1684, R12 - B callbackasm1(SB) - MOVD $1685, R12 - B callbackasm1(SB) - MOVD $1686, R12 - B callbackasm1(SB) - MOVD $1687, R12 - B callbackasm1(SB) - MOVD $1688, R12 - B callbackasm1(SB) - MOVD $1689, R12 - B callbackasm1(SB) - MOVD $1690, R12 - B callbackasm1(SB) - MOVD $1691, R12 - B callbackasm1(SB) - MOVD $1692, R12 - B callbackasm1(SB) - MOVD $1693, R12 - B callbackasm1(SB) - MOVD $1694, R12 - B callbackasm1(SB) - MOVD $1695, R12 - B callbackasm1(SB) - MOVD $1696, R12 - B callbackasm1(SB) - MOVD $1697, R12 - B callbackasm1(SB) - MOVD $1698, R12 - B callbackasm1(SB) - MOVD $1699, R12 - B callbackasm1(SB) - MOVD $1700, R12 - B callbackasm1(SB) - MOVD $1701, R12 - B callbackasm1(SB) - MOVD $1702, R12 - B callbackasm1(SB) - MOVD $1703, R12 - B callbackasm1(SB) - MOVD $1704, R12 - B callbackasm1(SB) - MOVD $1705, R12 - B callbackasm1(SB) - MOVD $1706, R12 - B callbackasm1(SB) - MOVD $1707, R12 - B callbackasm1(SB) - MOVD $1708, R12 - B callbackasm1(SB) - MOVD $1709, R12 - B callbackasm1(SB) - MOVD $1710, R12 - B callbackasm1(SB) - MOVD $1711, R12 - B callbackasm1(SB) - MOVD $1712, R12 - B callbackasm1(SB) - MOVD $1713, R12 - B callbackasm1(SB) - MOVD $1714, R12 - B callbackasm1(SB) - MOVD $1715, R12 - B callbackasm1(SB) - MOVD $1716, R12 - B callbackasm1(SB) - MOVD $1717, R12 - B callbackasm1(SB) - MOVD $1718, R12 - B callbackasm1(SB) - MOVD $1719, R12 - B callbackasm1(SB) - MOVD $1720, R12 - B callbackasm1(SB) - MOVD $1721, R12 - B callbackasm1(SB) - MOVD $1722, R12 - B callbackasm1(SB) - MOVD $1723, R12 - B callbackasm1(SB) - MOVD $1724, R12 - B callbackasm1(SB) - MOVD $1725, R12 - B callbackasm1(SB) - MOVD $1726, R12 - B callbackasm1(SB) - MOVD $1727, R12 - B callbackasm1(SB) - MOVD $1728, R12 - B callbackasm1(SB) - MOVD $1729, R12 - B callbackasm1(SB) - MOVD $1730, R12 - B callbackasm1(SB) - MOVD $1731, R12 - B callbackasm1(SB) - MOVD $1732, R12 - B callbackasm1(SB) - MOVD $1733, R12 - B callbackasm1(SB) - MOVD $1734, R12 - B callbackasm1(SB) - MOVD $1735, R12 - B callbackasm1(SB) - MOVD $1736, R12 - B callbackasm1(SB) - MOVD $1737, R12 - B callbackasm1(SB) - MOVD $1738, R12 - B callbackasm1(SB) - MOVD $1739, R12 - B callbackasm1(SB) - MOVD $1740, R12 - B callbackasm1(SB) - MOVD $1741, R12 - B callbackasm1(SB) - MOVD $1742, R12 - B callbackasm1(SB) - MOVD $1743, R12 - B callbackasm1(SB) - MOVD $1744, R12 - B callbackasm1(SB) - MOVD $1745, R12 - B callbackasm1(SB) - MOVD $1746, R12 - B callbackasm1(SB) - MOVD $1747, R12 - B callbackasm1(SB) - MOVD $1748, R12 - B callbackasm1(SB) - MOVD $1749, R12 - B callbackasm1(SB) - MOVD $1750, R12 - B callbackasm1(SB) - MOVD $1751, R12 - B callbackasm1(SB) - MOVD $1752, R12 - B callbackasm1(SB) - MOVD $1753, R12 - B callbackasm1(SB) - MOVD $1754, R12 - B callbackasm1(SB) - MOVD $1755, R12 - B callbackasm1(SB) - MOVD $1756, R12 - B callbackasm1(SB) - MOVD $1757, R12 - B callbackasm1(SB) - MOVD $1758, R12 - B callbackasm1(SB) - MOVD $1759, R12 - B callbackasm1(SB) - MOVD $1760, R12 - B callbackasm1(SB) - MOVD $1761, R12 - B callbackasm1(SB) - MOVD $1762, R12 - B callbackasm1(SB) - MOVD $1763, R12 - B callbackasm1(SB) - MOVD $1764, R12 - B callbackasm1(SB) - MOVD $1765, R12 - B callbackasm1(SB) - MOVD $1766, R12 - B callbackasm1(SB) - MOVD $1767, R12 - B callbackasm1(SB) - MOVD $1768, R12 - B callbackasm1(SB) - MOVD $1769, R12 - B callbackasm1(SB) - MOVD $1770, R12 - B callbackasm1(SB) - MOVD $1771, R12 - B callbackasm1(SB) - MOVD $1772, R12 - B callbackasm1(SB) - MOVD $1773, R12 - B callbackasm1(SB) - MOVD $1774, R12 - B callbackasm1(SB) - MOVD $1775, R12 - B callbackasm1(SB) - MOVD $1776, R12 - B callbackasm1(SB) - MOVD $1777, R12 - B callbackasm1(SB) - MOVD $1778, R12 - B callbackasm1(SB) - MOVD $1779, R12 - B callbackasm1(SB) - MOVD $1780, R12 - B callbackasm1(SB) - MOVD $1781, R12 - B callbackasm1(SB) - MOVD $1782, R12 - B callbackasm1(SB) - MOVD $1783, R12 - B callbackasm1(SB) - MOVD $1784, R12 - B callbackasm1(SB) - MOVD $1785, R12 - B callbackasm1(SB) - MOVD $1786, R12 - B callbackasm1(SB) - MOVD $1787, R12 - B callbackasm1(SB) - MOVD $1788, R12 - B callbackasm1(SB) - MOVD $1789, R12 - B callbackasm1(SB) - MOVD $1790, R12 - B callbackasm1(SB) - MOVD $1791, R12 - B callbackasm1(SB) - MOVD $1792, R12 - B callbackasm1(SB) - MOVD $1793, R12 - B callbackasm1(SB) - MOVD $1794, R12 - B callbackasm1(SB) - MOVD $1795, R12 - B callbackasm1(SB) - MOVD $1796, R12 - B callbackasm1(SB) - MOVD $1797, R12 - B callbackasm1(SB) - MOVD $1798, R12 - B callbackasm1(SB) - MOVD $1799, R12 - B callbackasm1(SB) - MOVD $1800, R12 - B callbackasm1(SB) - MOVD $1801, R12 - B callbackasm1(SB) - MOVD $1802, R12 - B callbackasm1(SB) - MOVD $1803, R12 - B callbackasm1(SB) - MOVD $1804, R12 - B callbackasm1(SB) - MOVD $1805, R12 - B callbackasm1(SB) - MOVD $1806, R12 - B callbackasm1(SB) - MOVD $1807, R12 - B callbackasm1(SB) - MOVD $1808, R12 - B callbackasm1(SB) - MOVD $1809, R12 - B callbackasm1(SB) - MOVD $1810, R12 - B callbackasm1(SB) - MOVD $1811, R12 - B callbackasm1(SB) - MOVD $1812, R12 - B callbackasm1(SB) - MOVD $1813, R12 - B callbackasm1(SB) - MOVD $1814, R12 - B callbackasm1(SB) - MOVD $1815, R12 - B callbackasm1(SB) - MOVD $1816, R12 - B callbackasm1(SB) - MOVD $1817, R12 - B callbackasm1(SB) - MOVD $1818, R12 - B callbackasm1(SB) - MOVD $1819, R12 - B callbackasm1(SB) - MOVD $1820, R12 - B callbackasm1(SB) - MOVD $1821, R12 - B callbackasm1(SB) - MOVD $1822, R12 - B callbackasm1(SB) - MOVD $1823, R12 - B callbackasm1(SB) - MOVD $1824, R12 - B callbackasm1(SB) - MOVD $1825, R12 - B callbackasm1(SB) - MOVD $1826, R12 - B callbackasm1(SB) - MOVD $1827, R12 - B callbackasm1(SB) - MOVD $1828, R12 - B callbackasm1(SB) - MOVD $1829, R12 - B callbackasm1(SB) - MOVD $1830, R12 - B callbackasm1(SB) - MOVD $1831, R12 - B callbackasm1(SB) - MOVD $1832, R12 - B callbackasm1(SB) - MOVD $1833, R12 - B callbackasm1(SB) - MOVD $1834, R12 - B callbackasm1(SB) - MOVD $1835, R12 - B callbackasm1(SB) - MOVD $1836, R12 - B callbackasm1(SB) - MOVD $1837, R12 - B callbackasm1(SB) - MOVD $1838, R12 - B callbackasm1(SB) - MOVD $1839, R12 - B callbackasm1(SB) - MOVD $1840, R12 - B callbackasm1(SB) - MOVD $1841, R12 - B callbackasm1(SB) - MOVD $1842, R12 - B callbackasm1(SB) - MOVD $1843, R12 - B callbackasm1(SB) - MOVD $1844, R12 - B callbackasm1(SB) - MOVD $1845, R12 - B callbackasm1(SB) - MOVD $1846, R12 - B callbackasm1(SB) - MOVD $1847, R12 - B callbackasm1(SB) - MOVD $1848, R12 - B callbackasm1(SB) - MOVD $1849, R12 - B callbackasm1(SB) - MOVD $1850, R12 - B callbackasm1(SB) - MOVD $1851, R12 - B callbackasm1(SB) - MOVD $1852, R12 - B callbackasm1(SB) - MOVD $1853, R12 - B callbackasm1(SB) - MOVD $1854, R12 - B callbackasm1(SB) - MOVD $1855, R12 - B callbackasm1(SB) - MOVD $1856, R12 - B callbackasm1(SB) - MOVD $1857, R12 - B callbackasm1(SB) - MOVD $1858, R12 - B callbackasm1(SB) - MOVD $1859, R12 - B callbackasm1(SB) - MOVD $1860, R12 - B callbackasm1(SB) - MOVD $1861, R12 - B callbackasm1(SB) - MOVD $1862, R12 - B callbackasm1(SB) - MOVD $1863, R12 - B callbackasm1(SB) - MOVD $1864, R12 - B callbackasm1(SB) - MOVD $1865, R12 - B callbackasm1(SB) - MOVD $1866, R12 - B callbackasm1(SB) - MOVD $1867, R12 - B callbackasm1(SB) - MOVD $1868, R12 - B callbackasm1(SB) - MOVD $1869, R12 - B callbackasm1(SB) - MOVD $1870, R12 - B callbackasm1(SB) - MOVD $1871, R12 - B callbackasm1(SB) - MOVD $1872, R12 - B callbackasm1(SB) - MOVD $1873, R12 - B callbackasm1(SB) - MOVD $1874, R12 - B callbackasm1(SB) - MOVD $1875, R12 - B callbackasm1(SB) - MOVD $1876, R12 - B callbackasm1(SB) - MOVD $1877, R12 - B callbackasm1(SB) - MOVD $1878, R12 - B callbackasm1(SB) - MOVD $1879, R12 - B callbackasm1(SB) - MOVD $1880, R12 - B callbackasm1(SB) - MOVD $1881, R12 - B callbackasm1(SB) - MOVD $1882, R12 - B callbackasm1(SB) - MOVD $1883, R12 - B callbackasm1(SB) - MOVD $1884, R12 - B callbackasm1(SB) - MOVD $1885, R12 - B callbackasm1(SB) - MOVD $1886, R12 - B callbackasm1(SB) - MOVD $1887, R12 - B callbackasm1(SB) - MOVD $1888, R12 - B callbackasm1(SB) - MOVD $1889, R12 - B callbackasm1(SB) - MOVD $1890, R12 - B callbackasm1(SB) - MOVD $1891, R12 - B callbackasm1(SB) - MOVD $1892, R12 - B callbackasm1(SB) - MOVD $1893, R12 - B callbackasm1(SB) - MOVD $1894, R12 - B callbackasm1(SB) - MOVD $1895, R12 - B callbackasm1(SB) - MOVD $1896, R12 - B callbackasm1(SB) - MOVD $1897, R12 - B callbackasm1(SB) - MOVD $1898, R12 - B callbackasm1(SB) - MOVD $1899, R12 - B callbackasm1(SB) - MOVD $1900, R12 - B callbackasm1(SB) - MOVD $1901, R12 - B callbackasm1(SB) - MOVD $1902, R12 - B callbackasm1(SB) - MOVD $1903, R12 - B callbackasm1(SB) - MOVD $1904, R12 - B callbackasm1(SB) - MOVD $1905, R12 - B callbackasm1(SB) - MOVD $1906, R12 - B callbackasm1(SB) - MOVD $1907, R12 - B callbackasm1(SB) - MOVD $1908, R12 - B callbackasm1(SB) - MOVD $1909, R12 - B callbackasm1(SB) - MOVD $1910, R12 - B callbackasm1(SB) - MOVD $1911, R12 - B callbackasm1(SB) - MOVD $1912, R12 - B callbackasm1(SB) - MOVD $1913, R12 - B callbackasm1(SB) - MOVD $1914, R12 - B callbackasm1(SB) - MOVD $1915, R12 - B callbackasm1(SB) - MOVD $1916, R12 - B callbackasm1(SB) - MOVD $1917, R12 - B callbackasm1(SB) - MOVD $1918, R12 - B callbackasm1(SB) - MOVD $1919, R12 - B callbackasm1(SB) - MOVD $1920, R12 - B callbackasm1(SB) - MOVD $1921, R12 - B callbackasm1(SB) - MOVD $1922, R12 - B callbackasm1(SB) - MOVD $1923, R12 - B callbackasm1(SB) - MOVD $1924, R12 - B callbackasm1(SB) - MOVD $1925, R12 - B callbackasm1(SB) - MOVD $1926, R12 - B callbackasm1(SB) - MOVD $1927, R12 - B callbackasm1(SB) - MOVD $1928, R12 - B callbackasm1(SB) - MOVD $1929, R12 - B callbackasm1(SB) - MOVD $1930, R12 - B callbackasm1(SB) - MOVD $1931, R12 - B callbackasm1(SB) - MOVD $1932, R12 - B callbackasm1(SB) - MOVD $1933, R12 - B callbackasm1(SB) - MOVD $1934, R12 - B callbackasm1(SB) - MOVD $1935, R12 - B callbackasm1(SB) - MOVD $1936, R12 - B callbackasm1(SB) - MOVD $1937, R12 - B callbackasm1(SB) - MOVD $1938, R12 - B callbackasm1(SB) - MOVD $1939, R12 - B callbackasm1(SB) - MOVD $1940, R12 - B callbackasm1(SB) - MOVD $1941, R12 - B callbackasm1(SB) - MOVD $1942, R12 - B callbackasm1(SB) - MOVD $1943, R12 - B callbackasm1(SB) - MOVD $1944, R12 - B callbackasm1(SB) - MOVD $1945, R12 - B callbackasm1(SB) - MOVD $1946, R12 - B callbackasm1(SB) - MOVD $1947, R12 - B callbackasm1(SB) - MOVD $1948, R12 - B callbackasm1(SB) - MOVD $1949, R12 - B callbackasm1(SB) - MOVD $1950, R12 - B callbackasm1(SB) - MOVD $1951, R12 - B callbackasm1(SB) - MOVD $1952, R12 - B callbackasm1(SB) - MOVD $1953, R12 - B callbackasm1(SB) - MOVD $1954, R12 - B callbackasm1(SB) - MOVD $1955, R12 - B callbackasm1(SB) - MOVD $1956, R12 - B callbackasm1(SB) - MOVD $1957, R12 - B callbackasm1(SB) - MOVD $1958, R12 - B callbackasm1(SB) - MOVD $1959, R12 - B callbackasm1(SB) - MOVD $1960, R12 - B callbackasm1(SB) - MOVD $1961, R12 - B callbackasm1(SB) - MOVD $1962, R12 - B callbackasm1(SB) - MOVD $1963, R12 - B callbackasm1(SB) - MOVD $1964, R12 - B callbackasm1(SB) - MOVD $1965, R12 - B callbackasm1(SB) - MOVD $1966, R12 - B callbackasm1(SB) - MOVD $1967, R12 - B callbackasm1(SB) - MOVD $1968, R12 - B callbackasm1(SB) - MOVD $1969, R12 - B callbackasm1(SB) - MOVD $1970, R12 - B callbackasm1(SB) - MOVD $1971, R12 - B callbackasm1(SB) - MOVD $1972, R12 - B callbackasm1(SB) - MOVD $1973, R12 - B callbackasm1(SB) - MOVD $1974, R12 - B callbackasm1(SB) - MOVD $1975, R12 - B callbackasm1(SB) - MOVD $1976, R12 - B callbackasm1(SB) - MOVD $1977, R12 - B callbackasm1(SB) - MOVD $1978, R12 - B callbackasm1(SB) - MOVD $1979, R12 - B callbackasm1(SB) - MOVD $1980, R12 - B callbackasm1(SB) - MOVD $1981, R12 - B callbackasm1(SB) - MOVD $1982, R12 - B callbackasm1(SB) - MOVD $1983, R12 - B callbackasm1(SB) - MOVD $1984, R12 - B callbackasm1(SB) - MOVD $1985, R12 - B callbackasm1(SB) - MOVD $1986, R12 - B callbackasm1(SB) - MOVD $1987, R12 - B callbackasm1(SB) - MOVD $1988, R12 - B callbackasm1(SB) - MOVD $1989, R12 - B callbackasm1(SB) - MOVD $1990, R12 - B callbackasm1(SB) - MOVD $1991, R12 - B callbackasm1(SB) - MOVD $1992, R12 - B callbackasm1(SB) - MOVD $1993, R12 - B callbackasm1(SB) - MOVD $1994, R12 - B callbackasm1(SB) - MOVD $1995, R12 - B callbackasm1(SB) - MOVD $1996, R12 - B callbackasm1(SB) - MOVD $1997, R12 - B callbackasm1(SB) - MOVD $1998, R12 - B callbackasm1(SB) - MOVD $1999, R12 - B callbackasm1(SB) +TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 + MOVD $0, R12 + B callbackasm1(SB) + MOVD $1, R12 + B callbackasm1(SB) + MOVD $2, R12 + B callbackasm1(SB) + MOVD $3, R12 + B callbackasm1(SB) + MOVD $4, R12 + B callbackasm1(SB) + MOVD $5, R12 + B callbackasm1(SB) + MOVD $6, R12 + B callbackasm1(SB) + MOVD $7, R12 + B callbackasm1(SB) + MOVD $8, R12 + B callbackasm1(SB) + MOVD $9, R12 + B callbackasm1(SB) + MOVD $10, R12 + B callbackasm1(SB) + MOVD $11, R12 + B callbackasm1(SB) + MOVD $12, R12 + B callbackasm1(SB) + MOVD $13, R12 + B callbackasm1(SB) + MOVD $14, R12 + B callbackasm1(SB) + MOVD $15, R12 + B callbackasm1(SB) + MOVD $16, R12 + B callbackasm1(SB) + MOVD $17, R12 + B callbackasm1(SB) + MOVD $18, R12 + B callbackasm1(SB) + MOVD $19, R12 + B callbackasm1(SB) + MOVD $20, R12 + B callbackasm1(SB) + MOVD $21, R12 + B callbackasm1(SB) + MOVD $22, R12 + B callbackasm1(SB) + MOVD $23, R12 + B callbackasm1(SB) + MOVD $24, R12 + B callbackasm1(SB) + MOVD $25, R12 + B callbackasm1(SB) + MOVD $26, R12 + B callbackasm1(SB) + MOVD $27, R12 + B callbackasm1(SB) + MOVD $28, R12 + B callbackasm1(SB) + MOVD $29, R12 + B callbackasm1(SB) + MOVD $30, R12 + B callbackasm1(SB) + MOVD $31, R12 + B callbackasm1(SB) + MOVD $32, R12 + B callbackasm1(SB) + MOVD $33, R12 + B callbackasm1(SB) + MOVD $34, R12 + B callbackasm1(SB) + MOVD $35, R12 + B callbackasm1(SB) + MOVD $36, R12 + B callbackasm1(SB) + MOVD $37, R12 + B callbackasm1(SB) + MOVD $38, R12 + B callbackasm1(SB) + MOVD $39, R12 + B callbackasm1(SB) + MOVD $40, R12 + B callbackasm1(SB) + MOVD $41, R12 + B callbackasm1(SB) + MOVD $42, R12 + B callbackasm1(SB) + MOVD $43, R12 + B callbackasm1(SB) + MOVD $44, R12 + B callbackasm1(SB) + MOVD $45, R12 + B callbackasm1(SB) + MOVD $46, R12 + B callbackasm1(SB) + MOVD $47, R12 + B callbackasm1(SB) + MOVD $48, R12 + B callbackasm1(SB) + MOVD $49, R12 + B callbackasm1(SB) + MOVD $50, R12 + B callbackasm1(SB) + MOVD $51, R12 + B callbackasm1(SB) + MOVD $52, R12 + B callbackasm1(SB) + MOVD $53, R12 + B callbackasm1(SB) + MOVD $54, R12 + B callbackasm1(SB) + MOVD $55, R12 + B callbackasm1(SB) + MOVD $56, R12 + B callbackasm1(SB) + MOVD $57, R12 + B callbackasm1(SB) + MOVD $58, R12 + B callbackasm1(SB) + MOVD $59, R12 + B callbackasm1(SB) + MOVD $60, R12 + B callbackasm1(SB) + MOVD $61, R12 + B callbackasm1(SB) + MOVD $62, R12 + B callbackasm1(SB) + MOVD $63, R12 + B callbackasm1(SB) + MOVD $64, R12 + B callbackasm1(SB) + MOVD $65, R12 + B callbackasm1(SB) + MOVD $66, R12 + B callbackasm1(SB) + MOVD $67, R12 + B callbackasm1(SB) + MOVD $68, R12 + B callbackasm1(SB) + MOVD $69, R12 + B callbackasm1(SB) + MOVD $70, R12 + B callbackasm1(SB) + MOVD $71, R12 + B callbackasm1(SB) + MOVD $72, R12 + B callbackasm1(SB) + MOVD $73, R12 + B callbackasm1(SB) + MOVD $74, R12 + B callbackasm1(SB) + MOVD $75, R12 + B callbackasm1(SB) + MOVD $76, R12 + B callbackasm1(SB) + MOVD $77, R12 + B callbackasm1(SB) + MOVD $78, R12 + B callbackasm1(SB) + MOVD $79, R12 + B callbackasm1(SB) + MOVD $80, R12 + B callbackasm1(SB) + MOVD $81, R12 + B callbackasm1(SB) + MOVD $82, R12 + B callbackasm1(SB) + MOVD $83, R12 + B callbackasm1(SB) + MOVD $84, R12 + B callbackasm1(SB) + MOVD $85, R12 + B callbackasm1(SB) + MOVD $86, R12 + B callbackasm1(SB) + MOVD $87, R12 + B callbackasm1(SB) + MOVD $88, R12 + B callbackasm1(SB) + MOVD $89, R12 + B callbackasm1(SB) + MOVD $90, R12 + B callbackasm1(SB) + MOVD $91, R12 + B callbackasm1(SB) + MOVD $92, R12 + B callbackasm1(SB) + MOVD $93, R12 + B callbackasm1(SB) + MOVD $94, R12 + B callbackasm1(SB) + MOVD $95, R12 + B callbackasm1(SB) + MOVD $96, R12 + B callbackasm1(SB) + MOVD $97, R12 + B callbackasm1(SB) + MOVD $98, R12 + B callbackasm1(SB) + MOVD $99, R12 + B callbackasm1(SB) + MOVD $100, R12 + B callbackasm1(SB) + MOVD $101, R12 + B callbackasm1(SB) + MOVD $102, R12 + B callbackasm1(SB) + MOVD $103, R12 + B callbackasm1(SB) + MOVD $104, R12 + B callbackasm1(SB) + MOVD $105, R12 + B callbackasm1(SB) + MOVD $106, R12 + B callbackasm1(SB) + MOVD $107, R12 + B callbackasm1(SB) + MOVD $108, R12 + B callbackasm1(SB) + MOVD $109, R12 + B callbackasm1(SB) + MOVD $110, R12 + B callbackasm1(SB) + MOVD $111, R12 + B callbackasm1(SB) + MOVD $112, R12 + B callbackasm1(SB) + MOVD $113, R12 + B callbackasm1(SB) + MOVD $114, R12 + B callbackasm1(SB) + MOVD $115, R12 + B callbackasm1(SB) + MOVD $116, R12 + B callbackasm1(SB) + MOVD $117, R12 + B callbackasm1(SB) + MOVD $118, R12 + B callbackasm1(SB) + MOVD $119, R12 + B callbackasm1(SB) + MOVD $120, R12 + B callbackasm1(SB) + MOVD $121, R12 + B callbackasm1(SB) + MOVD $122, R12 + B callbackasm1(SB) + MOVD $123, R12 + B callbackasm1(SB) + MOVD $124, R12 + B callbackasm1(SB) + MOVD $125, R12 + B callbackasm1(SB) + MOVD $126, R12 + B callbackasm1(SB) + MOVD $127, R12 + B callbackasm1(SB) + MOVD $128, R12 + B callbackasm1(SB) + MOVD $129, R12 + B callbackasm1(SB) + MOVD $130, R12 + B callbackasm1(SB) + MOVD $131, R12 + B callbackasm1(SB) + MOVD $132, R12 + B callbackasm1(SB) + MOVD $133, R12 + B callbackasm1(SB) + MOVD $134, R12 + B callbackasm1(SB) + MOVD $135, R12 + B callbackasm1(SB) + MOVD $136, R12 + B callbackasm1(SB) + MOVD $137, R12 + B callbackasm1(SB) + MOVD $138, R12 + B callbackasm1(SB) + MOVD $139, R12 + B callbackasm1(SB) + MOVD $140, R12 + B callbackasm1(SB) + MOVD $141, R12 + B callbackasm1(SB) + MOVD $142, R12 + B callbackasm1(SB) + MOVD $143, R12 + B callbackasm1(SB) + MOVD $144, R12 + B callbackasm1(SB) + MOVD $145, R12 + B callbackasm1(SB) + MOVD $146, R12 + B callbackasm1(SB) + MOVD $147, R12 + B callbackasm1(SB) + MOVD $148, R12 + B callbackasm1(SB) + MOVD $149, R12 + B callbackasm1(SB) + MOVD $150, R12 + B callbackasm1(SB) + MOVD $151, R12 + B callbackasm1(SB) + MOVD $152, R12 + B callbackasm1(SB) + MOVD $153, R12 + B callbackasm1(SB) + MOVD $154, R12 + B callbackasm1(SB) + MOVD $155, R12 + B callbackasm1(SB) + MOVD $156, R12 + B callbackasm1(SB) + MOVD $157, R12 + B callbackasm1(SB) + MOVD $158, R12 + B callbackasm1(SB) + MOVD $159, R12 + B callbackasm1(SB) + MOVD $160, R12 + B callbackasm1(SB) + MOVD $161, R12 + B callbackasm1(SB) + MOVD $162, R12 + B callbackasm1(SB) + MOVD $163, R12 + B callbackasm1(SB) + MOVD $164, R12 + B callbackasm1(SB) + MOVD $165, R12 + B callbackasm1(SB) + MOVD $166, R12 + B callbackasm1(SB) + MOVD $167, R12 + B callbackasm1(SB) + MOVD $168, R12 + B callbackasm1(SB) + MOVD $169, R12 + B callbackasm1(SB) + MOVD $170, R12 + B callbackasm1(SB) + MOVD $171, R12 + B callbackasm1(SB) + MOVD $172, R12 + B callbackasm1(SB) + MOVD $173, R12 + B callbackasm1(SB) + MOVD $174, R12 + B callbackasm1(SB) + MOVD $175, R12 + B callbackasm1(SB) + MOVD $176, R12 + B callbackasm1(SB) + MOVD $177, R12 + B callbackasm1(SB) + MOVD $178, R12 + B callbackasm1(SB) + MOVD $179, R12 + B callbackasm1(SB) + MOVD $180, R12 + B callbackasm1(SB) + MOVD $181, R12 + B callbackasm1(SB) + MOVD $182, R12 + B callbackasm1(SB) + MOVD $183, R12 + B callbackasm1(SB) + MOVD $184, R12 + B callbackasm1(SB) + MOVD $185, R12 + B callbackasm1(SB) + MOVD $186, R12 + B callbackasm1(SB) + MOVD $187, R12 + B callbackasm1(SB) + MOVD $188, R12 + B callbackasm1(SB) + MOVD $189, R12 + B callbackasm1(SB) + MOVD $190, R12 + B callbackasm1(SB) + MOVD $191, R12 + B callbackasm1(SB) + MOVD $192, R12 + B callbackasm1(SB) + MOVD $193, R12 + B callbackasm1(SB) + MOVD $194, R12 + B callbackasm1(SB) + MOVD $195, R12 + B callbackasm1(SB) + MOVD $196, R12 + B callbackasm1(SB) + MOVD $197, R12 + B callbackasm1(SB) + MOVD $198, R12 + B callbackasm1(SB) + MOVD $199, R12 + B callbackasm1(SB) + MOVD $200, R12 + B callbackasm1(SB) + MOVD $201, R12 + B callbackasm1(SB) + MOVD $202, R12 + B callbackasm1(SB) + MOVD $203, R12 + B callbackasm1(SB) + MOVD $204, R12 + B callbackasm1(SB) + MOVD $205, R12 + B callbackasm1(SB) + MOVD $206, R12 + B callbackasm1(SB) + MOVD $207, R12 + B callbackasm1(SB) + MOVD $208, R12 + B callbackasm1(SB) + MOVD $209, R12 + B callbackasm1(SB) + MOVD $210, R12 + B callbackasm1(SB) + MOVD $211, R12 + B callbackasm1(SB) + MOVD $212, R12 + B callbackasm1(SB) + MOVD $213, R12 + B callbackasm1(SB) + MOVD $214, R12 + B callbackasm1(SB) + MOVD $215, R12 + B callbackasm1(SB) + MOVD $216, R12 + B callbackasm1(SB) + MOVD $217, R12 + B callbackasm1(SB) + MOVD $218, R12 + B callbackasm1(SB) + MOVD $219, R12 + B callbackasm1(SB) + MOVD $220, R12 + B callbackasm1(SB) + MOVD $221, R12 + B callbackasm1(SB) + MOVD $222, R12 + B callbackasm1(SB) + MOVD $223, R12 + B callbackasm1(SB) + MOVD $224, R12 + B callbackasm1(SB) + MOVD $225, R12 + B callbackasm1(SB) + MOVD $226, R12 + B callbackasm1(SB) + MOVD $227, R12 + B callbackasm1(SB) + MOVD $228, R12 + B callbackasm1(SB) + MOVD $229, R12 + B callbackasm1(SB) + MOVD $230, R12 + B callbackasm1(SB) + MOVD $231, R12 + B callbackasm1(SB) + MOVD $232, R12 + B callbackasm1(SB) + MOVD $233, R12 + B callbackasm1(SB) + MOVD $234, R12 + B callbackasm1(SB) + MOVD $235, R12 + B callbackasm1(SB) + MOVD $236, R12 + B callbackasm1(SB) + MOVD $237, R12 + B callbackasm1(SB) + MOVD $238, R12 + B callbackasm1(SB) + MOVD $239, R12 + B callbackasm1(SB) + MOVD $240, R12 + B callbackasm1(SB) + MOVD $241, R12 + B callbackasm1(SB) + MOVD $242, R12 + B callbackasm1(SB) + MOVD $243, R12 + B callbackasm1(SB) + MOVD $244, R12 + B callbackasm1(SB) + MOVD $245, R12 + B callbackasm1(SB) + MOVD $246, R12 + B callbackasm1(SB) + MOVD $247, R12 + B callbackasm1(SB) + MOVD $248, R12 + B callbackasm1(SB) + MOVD $249, R12 + B callbackasm1(SB) + MOVD $250, R12 + B callbackasm1(SB) + MOVD $251, R12 + B callbackasm1(SB) + MOVD $252, R12 + B callbackasm1(SB) + MOVD $253, R12 + B callbackasm1(SB) + MOVD $254, R12 + B callbackasm1(SB) + MOVD $255, R12 + B callbackasm1(SB) + MOVD $256, R12 + B callbackasm1(SB) + MOVD $257, R12 + B callbackasm1(SB) + MOVD $258, R12 + B callbackasm1(SB) + MOVD $259, R12 + B callbackasm1(SB) + MOVD $260, R12 + B callbackasm1(SB) + MOVD $261, R12 + B callbackasm1(SB) + MOVD $262, R12 + B callbackasm1(SB) + MOVD $263, R12 + B callbackasm1(SB) + MOVD $264, R12 + B callbackasm1(SB) + MOVD $265, R12 + B callbackasm1(SB) + MOVD $266, R12 + B callbackasm1(SB) + MOVD $267, R12 + B callbackasm1(SB) + MOVD $268, R12 + B callbackasm1(SB) + MOVD $269, R12 + B callbackasm1(SB) + MOVD $270, R12 + B callbackasm1(SB) + MOVD $271, R12 + B callbackasm1(SB) + MOVD $272, R12 + B callbackasm1(SB) + MOVD $273, R12 + B callbackasm1(SB) + MOVD $274, R12 + B callbackasm1(SB) + MOVD $275, R12 + B callbackasm1(SB) + MOVD $276, R12 + B callbackasm1(SB) + MOVD $277, R12 + B callbackasm1(SB) + MOVD $278, R12 + B callbackasm1(SB) + MOVD $279, R12 + B callbackasm1(SB) + MOVD $280, R12 + B callbackasm1(SB) + MOVD $281, R12 + B callbackasm1(SB) + MOVD $282, R12 + B callbackasm1(SB) + MOVD $283, R12 + B callbackasm1(SB) + MOVD $284, R12 + B callbackasm1(SB) + MOVD $285, R12 + B callbackasm1(SB) + MOVD $286, R12 + B callbackasm1(SB) + MOVD $287, R12 + B callbackasm1(SB) + MOVD $288, R12 + B callbackasm1(SB) + MOVD $289, R12 + B callbackasm1(SB) + MOVD $290, R12 + B callbackasm1(SB) + MOVD $291, R12 + B callbackasm1(SB) + MOVD $292, R12 + B callbackasm1(SB) + MOVD $293, R12 + B callbackasm1(SB) + MOVD $294, R12 + B callbackasm1(SB) + MOVD $295, R12 + B callbackasm1(SB) + MOVD $296, R12 + B callbackasm1(SB) + MOVD $297, R12 + B callbackasm1(SB) + MOVD $298, R12 + B callbackasm1(SB) + MOVD $299, R12 + B callbackasm1(SB) + MOVD $300, R12 + B callbackasm1(SB) + MOVD $301, R12 + B callbackasm1(SB) + MOVD $302, R12 + B callbackasm1(SB) + MOVD $303, R12 + B callbackasm1(SB) + MOVD $304, R12 + B callbackasm1(SB) + MOVD $305, R12 + B callbackasm1(SB) + MOVD $306, R12 + B callbackasm1(SB) + MOVD $307, R12 + B callbackasm1(SB) + MOVD $308, R12 + B callbackasm1(SB) + MOVD $309, R12 + B callbackasm1(SB) + MOVD $310, R12 + B callbackasm1(SB) + MOVD $311, R12 + B callbackasm1(SB) + MOVD $312, R12 + B callbackasm1(SB) + MOVD $313, R12 + B callbackasm1(SB) + MOVD $314, R12 + B callbackasm1(SB) + MOVD $315, R12 + B callbackasm1(SB) + MOVD $316, R12 + B callbackasm1(SB) + MOVD $317, R12 + B callbackasm1(SB) + MOVD $318, R12 + B callbackasm1(SB) + MOVD $319, R12 + B callbackasm1(SB) + MOVD $320, R12 + B callbackasm1(SB) + MOVD $321, R12 + B callbackasm1(SB) + MOVD $322, R12 + B callbackasm1(SB) + MOVD $323, R12 + B callbackasm1(SB) + MOVD $324, R12 + B callbackasm1(SB) + MOVD $325, R12 + B callbackasm1(SB) + MOVD $326, R12 + B callbackasm1(SB) + MOVD $327, R12 + B callbackasm1(SB) + MOVD $328, R12 + B callbackasm1(SB) + MOVD $329, R12 + B callbackasm1(SB) + MOVD $330, R12 + B callbackasm1(SB) + MOVD $331, R12 + B callbackasm1(SB) + MOVD $332, R12 + B callbackasm1(SB) + MOVD $333, R12 + B callbackasm1(SB) + MOVD $334, R12 + B callbackasm1(SB) + MOVD $335, R12 + B callbackasm1(SB) + MOVD $336, R12 + B callbackasm1(SB) + MOVD $337, R12 + B callbackasm1(SB) + MOVD $338, R12 + B callbackasm1(SB) + MOVD $339, R12 + B callbackasm1(SB) + MOVD $340, R12 + B callbackasm1(SB) + MOVD $341, R12 + B callbackasm1(SB) + MOVD $342, R12 + B callbackasm1(SB) + MOVD $343, R12 + B callbackasm1(SB) + MOVD $344, R12 + B callbackasm1(SB) + MOVD $345, R12 + B callbackasm1(SB) + MOVD $346, R12 + B callbackasm1(SB) + MOVD $347, R12 + B callbackasm1(SB) + MOVD $348, R12 + B callbackasm1(SB) + MOVD $349, R12 + B callbackasm1(SB) + MOVD $350, R12 + B callbackasm1(SB) + MOVD $351, R12 + B callbackasm1(SB) + MOVD $352, R12 + B callbackasm1(SB) + MOVD $353, R12 + B callbackasm1(SB) + MOVD $354, R12 + B callbackasm1(SB) + MOVD $355, R12 + B callbackasm1(SB) + MOVD $356, R12 + B callbackasm1(SB) + MOVD $357, R12 + B callbackasm1(SB) + MOVD $358, R12 + B callbackasm1(SB) + MOVD $359, R12 + B callbackasm1(SB) + MOVD $360, R12 + B callbackasm1(SB) + MOVD $361, R12 + B callbackasm1(SB) + MOVD $362, R12 + B callbackasm1(SB) + MOVD $363, R12 + B callbackasm1(SB) + MOVD $364, R12 + B callbackasm1(SB) + MOVD $365, R12 + B callbackasm1(SB) + MOVD $366, R12 + B callbackasm1(SB) + MOVD $367, R12 + B callbackasm1(SB) + MOVD $368, R12 + B callbackasm1(SB) + MOVD $369, R12 + B callbackasm1(SB) + MOVD $370, R12 + B callbackasm1(SB) + MOVD $371, R12 + B callbackasm1(SB) + MOVD $372, R12 + B callbackasm1(SB) + MOVD $373, R12 + B callbackasm1(SB) + MOVD $374, R12 + B callbackasm1(SB) + MOVD $375, R12 + B callbackasm1(SB) + MOVD $376, R12 + B callbackasm1(SB) + MOVD $377, R12 + B callbackasm1(SB) + MOVD $378, R12 + B callbackasm1(SB) + MOVD $379, R12 + B callbackasm1(SB) + MOVD $380, R12 + B callbackasm1(SB) + MOVD $381, R12 + B callbackasm1(SB) + MOVD $382, R12 + B callbackasm1(SB) + MOVD $383, R12 + B callbackasm1(SB) + MOVD $384, R12 + B callbackasm1(SB) + MOVD $385, R12 + B callbackasm1(SB) + MOVD $386, R12 + B callbackasm1(SB) + MOVD $387, R12 + B callbackasm1(SB) + MOVD $388, R12 + B callbackasm1(SB) + MOVD $389, R12 + B callbackasm1(SB) + MOVD $390, R12 + B callbackasm1(SB) + MOVD $391, R12 + B callbackasm1(SB) + MOVD $392, R12 + B callbackasm1(SB) + MOVD $393, R12 + B callbackasm1(SB) + MOVD $394, R12 + B callbackasm1(SB) + MOVD $395, R12 + B callbackasm1(SB) + MOVD $396, R12 + B callbackasm1(SB) + MOVD $397, R12 + B callbackasm1(SB) + MOVD $398, R12 + B callbackasm1(SB) + MOVD $399, R12 + B callbackasm1(SB) + MOVD $400, R12 + B callbackasm1(SB) + MOVD $401, R12 + B callbackasm1(SB) + MOVD $402, R12 + B callbackasm1(SB) + MOVD $403, R12 + B callbackasm1(SB) + MOVD $404, R12 + B callbackasm1(SB) + MOVD $405, R12 + B callbackasm1(SB) + MOVD $406, R12 + B callbackasm1(SB) + MOVD $407, R12 + B callbackasm1(SB) + MOVD $408, R12 + B callbackasm1(SB) + MOVD $409, R12 + B callbackasm1(SB) + MOVD $410, R12 + B callbackasm1(SB) + MOVD $411, R12 + B callbackasm1(SB) + MOVD $412, R12 + B callbackasm1(SB) + MOVD $413, R12 + B callbackasm1(SB) + MOVD $414, R12 + B callbackasm1(SB) + MOVD $415, R12 + B callbackasm1(SB) + MOVD $416, R12 + B callbackasm1(SB) + MOVD $417, R12 + B callbackasm1(SB) + MOVD $418, R12 + B callbackasm1(SB) + MOVD $419, R12 + B callbackasm1(SB) + MOVD $420, R12 + B callbackasm1(SB) + MOVD $421, R12 + B callbackasm1(SB) + MOVD $422, R12 + B callbackasm1(SB) + MOVD $423, R12 + B callbackasm1(SB) + MOVD $424, R12 + B callbackasm1(SB) + MOVD $425, R12 + B callbackasm1(SB) + MOVD $426, R12 + B callbackasm1(SB) + MOVD $427, R12 + B callbackasm1(SB) + MOVD $428, R12 + B callbackasm1(SB) + MOVD $429, R12 + B callbackasm1(SB) + MOVD $430, R12 + B callbackasm1(SB) + MOVD $431, R12 + B callbackasm1(SB) + MOVD $432, R12 + B callbackasm1(SB) + MOVD $433, R12 + B callbackasm1(SB) + MOVD $434, R12 + B callbackasm1(SB) + MOVD $435, R12 + B callbackasm1(SB) + MOVD $436, R12 + B callbackasm1(SB) + MOVD $437, R12 + B callbackasm1(SB) + MOVD $438, R12 + B callbackasm1(SB) + MOVD $439, R12 + B callbackasm1(SB) + MOVD $440, R12 + B callbackasm1(SB) + MOVD $441, R12 + B callbackasm1(SB) + MOVD $442, R12 + B callbackasm1(SB) + MOVD $443, R12 + B callbackasm1(SB) + MOVD $444, R12 + B callbackasm1(SB) + MOVD $445, R12 + B callbackasm1(SB) + MOVD $446, R12 + B callbackasm1(SB) + MOVD $447, R12 + B callbackasm1(SB) + MOVD $448, R12 + B callbackasm1(SB) + MOVD $449, R12 + B callbackasm1(SB) + MOVD $450, R12 + B callbackasm1(SB) + MOVD $451, R12 + B callbackasm1(SB) + MOVD $452, R12 + B callbackasm1(SB) + MOVD $453, R12 + B callbackasm1(SB) + MOVD $454, R12 + B callbackasm1(SB) + MOVD $455, R12 + B callbackasm1(SB) + MOVD $456, R12 + B callbackasm1(SB) + MOVD $457, R12 + B callbackasm1(SB) + MOVD $458, R12 + B callbackasm1(SB) + MOVD $459, R12 + B callbackasm1(SB) + MOVD $460, R12 + B callbackasm1(SB) + MOVD $461, R12 + B callbackasm1(SB) + MOVD $462, R12 + B callbackasm1(SB) + MOVD $463, R12 + B callbackasm1(SB) + MOVD $464, R12 + B callbackasm1(SB) + MOVD $465, R12 + B callbackasm1(SB) + MOVD $466, R12 + B callbackasm1(SB) + MOVD $467, R12 + B callbackasm1(SB) + MOVD $468, R12 + B callbackasm1(SB) + MOVD $469, R12 + B callbackasm1(SB) + MOVD $470, R12 + B callbackasm1(SB) + MOVD $471, R12 + B callbackasm1(SB) + MOVD $472, R12 + B callbackasm1(SB) + MOVD $473, R12 + B callbackasm1(SB) + MOVD $474, R12 + B callbackasm1(SB) + MOVD $475, R12 + B callbackasm1(SB) + MOVD $476, R12 + B callbackasm1(SB) + MOVD $477, R12 + B callbackasm1(SB) + MOVD $478, R12 + B callbackasm1(SB) + MOVD $479, R12 + B callbackasm1(SB) + MOVD $480, R12 + B callbackasm1(SB) + MOVD $481, R12 + B callbackasm1(SB) + MOVD $482, R12 + B callbackasm1(SB) + MOVD $483, R12 + B callbackasm1(SB) + MOVD $484, R12 + B callbackasm1(SB) + MOVD $485, R12 + B callbackasm1(SB) + MOVD $486, R12 + B callbackasm1(SB) + MOVD $487, R12 + B callbackasm1(SB) + MOVD $488, R12 + B callbackasm1(SB) + MOVD $489, R12 + B callbackasm1(SB) + MOVD $490, R12 + B callbackasm1(SB) + MOVD $491, R12 + B callbackasm1(SB) + MOVD $492, R12 + B callbackasm1(SB) + MOVD $493, R12 + B callbackasm1(SB) + MOVD $494, R12 + B callbackasm1(SB) + MOVD $495, R12 + B callbackasm1(SB) + MOVD $496, R12 + B callbackasm1(SB) + MOVD $497, R12 + B callbackasm1(SB) + MOVD $498, R12 + B callbackasm1(SB) + MOVD $499, R12 + B callbackasm1(SB) + MOVD $500, R12 + B callbackasm1(SB) + MOVD $501, R12 + B callbackasm1(SB) + MOVD $502, R12 + B callbackasm1(SB) + MOVD $503, R12 + B callbackasm1(SB) + MOVD $504, R12 + B callbackasm1(SB) + MOVD $505, R12 + B callbackasm1(SB) + MOVD $506, R12 + B callbackasm1(SB) + MOVD $507, R12 + B callbackasm1(SB) + MOVD $508, R12 + B callbackasm1(SB) + MOVD $509, R12 + B callbackasm1(SB) + MOVD $510, R12 + B callbackasm1(SB) + MOVD $511, R12 + B callbackasm1(SB) + MOVD $512, R12 + B callbackasm1(SB) + MOVD $513, R12 + B callbackasm1(SB) + MOVD $514, R12 + B callbackasm1(SB) + MOVD $515, R12 + B callbackasm1(SB) + MOVD $516, R12 + B callbackasm1(SB) + MOVD $517, R12 + B callbackasm1(SB) + MOVD $518, R12 + B callbackasm1(SB) + MOVD $519, R12 + B callbackasm1(SB) + MOVD $520, R12 + B callbackasm1(SB) + MOVD $521, R12 + B callbackasm1(SB) + MOVD $522, R12 + B callbackasm1(SB) + MOVD $523, R12 + B callbackasm1(SB) + MOVD $524, R12 + B callbackasm1(SB) + MOVD $525, R12 + B callbackasm1(SB) + MOVD $526, R12 + B callbackasm1(SB) + MOVD $527, R12 + B callbackasm1(SB) + MOVD $528, R12 + B callbackasm1(SB) + MOVD $529, R12 + B callbackasm1(SB) + MOVD $530, R12 + B callbackasm1(SB) + MOVD $531, R12 + B callbackasm1(SB) + MOVD $532, R12 + B callbackasm1(SB) + MOVD $533, R12 + B callbackasm1(SB) + MOVD $534, R12 + B callbackasm1(SB) + MOVD $535, R12 + B callbackasm1(SB) + MOVD $536, R12 + B callbackasm1(SB) + MOVD $537, R12 + B callbackasm1(SB) + MOVD $538, R12 + B callbackasm1(SB) + MOVD $539, R12 + B callbackasm1(SB) + MOVD $540, R12 + B callbackasm1(SB) + MOVD $541, R12 + B callbackasm1(SB) + MOVD $542, R12 + B callbackasm1(SB) + MOVD $543, R12 + B callbackasm1(SB) + MOVD $544, R12 + B callbackasm1(SB) + MOVD $545, R12 + B callbackasm1(SB) + MOVD $546, R12 + B callbackasm1(SB) + MOVD $547, R12 + B callbackasm1(SB) + MOVD $548, R12 + B callbackasm1(SB) + MOVD $549, R12 + B callbackasm1(SB) + MOVD $550, R12 + B callbackasm1(SB) + MOVD $551, R12 + B callbackasm1(SB) + MOVD $552, R12 + B callbackasm1(SB) + MOVD $553, R12 + B callbackasm1(SB) + MOVD $554, R12 + B callbackasm1(SB) + MOVD $555, R12 + B callbackasm1(SB) + MOVD $556, R12 + B callbackasm1(SB) + MOVD $557, R12 + B callbackasm1(SB) + MOVD $558, R12 + B callbackasm1(SB) + MOVD $559, R12 + B callbackasm1(SB) + MOVD $560, R12 + B callbackasm1(SB) + MOVD $561, R12 + B callbackasm1(SB) + MOVD $562, R12 + B callbackasm1(SB) + MOVD $563, R12 + B callbackasm1(SB) + MOVD $564, R12 + B callbackasm1(SB) + MOVD $565, R12 + B callbackasm1(SB) + MOVD $566, R12 + B callbackasm1(SB) + MOVD $567, R12 + B callbackasm1(SB) + MOVD $568, R12 + B callbackasm1(SB) + MOVD $569, R12 + B callbackasm1(SB) + MOVD $570, R12 + B callbackasm1(SB) + MOVD $571, R12 + B callbackasm1(SB) + MOVD $572, R12 + B callbackasm1(SB) + MOVD $573, R12 + B callbackasm1(SB) + MOVD $574, R12 + B callbackasm1(SB) + MOVD $575, R12 + B callbackasm1(SB) + MOVD $576, R12 + B callbackasm1(SB) + MOVD $577, R12 + B callbackasm1(SB) + MOVD $578, R12 + B callbackasm1(SB) + MOVD $579, R12 + B callbackasm1(SB) + MOVD $580, R12 + B callbackasm1(SB) + MOVD $581, R12 + B callbackasm1(SB) + MOVD $582, R12 + B callbackasm1(SB) + MOVD $583, R12 + B callbackasm1(SB) + MOVD $584, R12 + B callbackasm1(SB) + MOVD $585, R12 + B callbackasm1(SB) + MOVD $586, R12 + B callbackasm1(SB) + MOVD $587, R12 + B callbackasm1(SB) + MOVD $588, R12 + B callbackasm1(SB) + MOVD $589, R12 + B callbackasm1(SB) + MOVD $590, R12 + B callbackasm1(SB) + MOVD $591, R12 + B callbackasm1(SB) + MOVD $592, R12 + B callbackasm1(SB) + MOVD $593, R12 + B callbackasm1(SB) + MOVD $594, R12 + B callbackasm1(SB) + MOVD $595, R12 + B callbackasm1(SB) + MOVD $596, R12 + B callbackasm1(SB) + MOVD $597, R12 + B callbackasm1(SB) + MOVD $598, R12 + B callbackasm1(SB) + MOVD $599, R12 + B callbackasm1(SB) + MOVD $600, R12 + B callbackasm1(SB) + MOVD $601, R12 + B callbackasm1(SB) + MOVD $602, R12 + B callbackasm1(SB) + MOVD $603, R12 + B callbackasm1(SB) + MOVD $604, R12 + B callbackasm1(SB) + MOVD $605, R12 + B callbackasm1(SB) + MOVD $606, R12 + B callbackasm1(SB) + MOVD $607, R12 + B callbackasm1(SB) + MOVD $608, R12 + B callbackasm1(SB) + MOVD $609, R12 + B callbackasm1(SB) + MOVD $610, R12 + B callbackasm1(SB) + MOVD $611, R12 + B callbackasm1(SB) + MOVD $612, R12 + B callbackasm1(SB) + MOVD $613, R12 + B callbackasm1(SB) + MOVD $614, R12 + B callbackasm1(SB) + MOVD $615, R12 + B callbackasm1(SB) + MOVD $616, R12 + B callbackasm1(SB) + MOVD $617, R12 + B callbackasm1(SB) + MOVD $618, R12 + B callbackasm1(SB) + MOVD $619, R12 + B callbackasm1(SB) + MOVD $620, R12 + B callbackasm1(SB) + MOVD $621, R12 + B callbackasm1(SB) + MOVD $622, R12 + B callbackasm1(SB) + MOVD $623, R12 + B callbackasm1(SB) + MOVD $624, R12 + B callbackasm1(SB) + MOVD $625, R12 + B callbackasm1(SB) + MOVD $626, R12 + B callbackasm1(SB) + MOVD $627, R12 + B callbackasm1(SB) + MOVD $628, R12 + B callbackasm1(SB) + MOVD $629, R12 + B callbackasm1(SB) + MOVD $630, R12 + B callbackasm1(SB) + MOVD $631, R12 + B callbackasm1(SB) + MOVD $632, R12 + B callbackasm1(SB) + MOVD $633, R12 + B callbackasm1(SB) + MOVD $634, R12 + B callbackasm1(SB) + MOVD $635, R12 + B callbackasm1(SB) + MOVD $636, R12 + B callbackasm1(SB) + MOVD $637, R12 + B callbackasm1(SB) + MOVD $638, R12 + B callbackasm1(SB) + MOVD $639, R12 + B callbackasm1(SB) + MOVD $640, R12 + B callbackasm1(SB) + MOVD $641, R12 + B callbackasm1(SB) + MOVD $642, R12 + B callbackasm1(SB) + MOVD $643, R12 + B callbackasm1(SB) + MOVD $644, R12 + B callbackasm1(SB) + MOVD $645, R12 + B callbackasm1(SB) + MOVD $646, R12 + B callbackasm1(SB) + MOVD $647, R12 + B callbackasm1(SB) + MOVD $648, R12 + B callbackasm1(SB) + MOVD $649, R12 + B callbackasm1(SB) + MOVD $650, R12 + B callbackasm1(SB) + MOVD $651, R12 + B callbackasm1(SB) + MOVD $652, R12 + B callbackasm1(SB) + MOVD $653, R12 + B callbackasm1(SB) + MOVD $654, R12 + B callbackasm1(SB) + MOVD $655, R12 + B callbackasm1(SB) + MOVD $656, R12 + B callbackasm1(SB) + MOVD $657, R12 + B callbackasm1(SB) + MOVD $658, R12 + B callbackasm1(SB) + MOVD $659, R12 + B callbackasm1(SB) + MOVD $660, R12 + B callbackasm1(SB) + MOVD $661, R12 + B callbackasm1(SB) + MOVD $662, R12 + B callbackasm1(SB) + MOVD $663, R12 + B callbackasm1(SB) + MOVD $664, R12 + B callbackasm1(SB) + MOVD $665, R12 + B callbackasm1(SB) + MOVD $666, R12 + B callbackasm1(SB) + MOVD $667, R12 + B callbackasm1(SB) + MOVD $668, R12 + B callbackasm1(SB) + MOVD $669, R12 + B callbackasm1(SB) + MOVD $670, R12 + B callbackasm1(SB) + MOVD $671, R12 + B callbackasm1(SB) + MOVD $672, R12 + B callbackasm1(SB) + MOVD $673, R12 + B callbackasm1(SB) + MOVD $674, R12 + B callbackasm1(SB) + MOVD $675, R12 + B callbackasm1(SB) + MOVD $676, R12 + B callbackasm1(SB) + MOVD $677, R12 + B callbackasm1(SB) + MOVD $678, R12 + B callbackasm1(SB) + MOVD $679, R12 + B callbackasm1(SB) + MOVD $680, R12 + B callbackasm1(SB) + MOVD $681, R12 + B callbackasm1(SB) + MOVD $682, R12 + B callbackasm1(SB) + MOVD $683, R12 + B callbackasm1(SB) + MOVD $684, R12 + B callbackasm1(SB) + MOVD $685, R12 + B callbackasm1(SB) + MOVD $686, R12 + B callbackasm1(SB) + MOVD $687, R12 + B callbackasm1(SB) + MOVD $688, R12 + B callbackasm1(SB) + MOVD $689, R12 + B callbackasm1(SB) + MOVD $690, R12 + B callbackasm1(SB) + MOVD $691, R12 + B callbackasm1(SB) + MOVD $692, R12 + B callbackasm1(SB) + MOVD $693, R12 + B callbackasm1(SB) + MOVD $694, R12 + B callbackasm1(SB) + MOVD $695, R12 + B callbackasm1(SB) + MOVD $696, R12 + B callbackasm1(SB) + MOVD $697, R12 + B callbackasm1(SB) + MOVD $698, R12 + B callbackasm1(SB) + MOVD $699, R12 + B callbackasm1(SB) + MOVD $700, R12 + B callbackasm1(SB) + MOVD $701, R12 + B callbackasm1(SB) + MOVD $702, R12 + B callbackasm1(SB) + MOVD $703, R12 + B callbackasm1(SB) + MOVD $704, R12 + B callbackasm1(SB) + MOVD $705, R12 + B callbackasm1(SB) + MOVD $706, R12 + B callbackasm1(SB) + MOVD $707, R12 + B callbackasm1(SB) + MOVD $708, R12 + B callbackasm1(SB) + MOVD $709, R12 + B callbackasm1(SB) + MOVD $710, R12 + B callbackasm1(SB) + MOVD $711, R12 + B callbackasm1(SB) + MOVD $712, R12 + B callbackasm1(SB) + MOVD $713, R12 + B callbackasm1(SB) + MOVD $714, R12 + B callbackasm1(SB) + MOVD $715, R12 + B callbackasm1(SB) + MOVD $716, R12 + B callbackasm1(SB) + MOVD $717, R12 + B callbackasm1(SB) + MOVD $718, R12 + B callbackasm1(SB) + MOVD $719, R12 + B callbackasm1(SB) + MOVD $720, R12 + B callbackasm1(SB) + MOVD $721, R12 + B callbackasm1(SB) + MOVD $722, R12 + B callbackasm1(SB) + MOVD $723, R12 + B callbackasm1(SB) + MOVD $724, R12 + B callbackasm1(SB) + MOVD $725, R12 + B callbackasm1(SB) + MOVD $726, R12 + B callbackasm1(SB) + MOVD $727, R12 + B callbackasm1(SB) + MOVD $728, R12 + B callbackasm1(SB) + MOVD $729, R12 + B callbackasm1(SB) + MOVD $730, R12 + B callbackasm1(SB) + MOVD $731, R12 + B callbackasm1(SB) + MOVD $732, R12 + B callbackasm1(SB) + MOVD $733, R12 + B callbackasm1(SB) + MOVD $734, R12 + B callbackasm1(SB) + MOVD $735, R12 + B callbackasm1(SB) + MOVD $736, R12 + B callbackasm1(SB) + MOVD $737, R12 + B callbackasm1(SB) + MOVD $738, R12 + B callbackasm1(SB) + MOVD $739, R12 + B callbackasm1(SB) + MOVD $740, R12 + B callbackasm1(SB) + MOVD $741, R12 + B callbackasm1(SB) + MOVD $742, R12 + B callbackasm1(SB) + MOVD $743, R12 + B callbackasm1(SB) + MOVD $744, R12 + B callbackasm1(SB) + MOVD $745, R12 + B callbackasm1(SB) + MOVD $746, R12 + B callbackasm1(SB) + MOVD $747, R12 + B callbackasm1(SB) + MOVD $748, R12 + B callbackasm1(SB) + MOVD $749, R12 + B callbackasm1(SB) + MOVD $750, R12 + B callbackasm1(SB) + MOVD $751, R12 + B callbackasm1(SB) + MOVD $752, R12 + B callbackasm1(SB) + MOVD $753, R12 + B callbackasm1(SB) + MOVD $754, R12 + B callbackasm1(SB) + MOVD $755, R12 + B callbackasm1(SB) + MOVD $756, R12 + B callbackasm1(SB) + MOVD $757, R12 + B callbackasm1(SB) + MOVD $758, R12 + B callbackasm1(SB) + MOVD $759, R12 + B callbackasm1(SB) + MOVD $760, R12 + B callbackasm1(SB) + MOVD $761, R12 + B callbackasm1(SB) + MOVD $762, R12 + B callbackasm1(SB) + MOVD $763, R12 + B callbackasm1(SB) + MOVD $764, R12 + B callbackasm1(SB) + MOVD $765, R12 + B callbackasm1(SB) + MOVD $766, R12 + B callbackasm1(SB) + MOVD $767, R12 + B callbackasm1(SB) + MOVD $768, R12 + B callbackasm1(SB) + MOVD $769, R12 + B callbackasm1(SB) + MOVD $770, R12 + B callbackasm1(SB) + MOVD $771, R12 + B callbackasm1(SB) + MOVD $772, R12 + B callbackasm1(SB) + MOVD $773, R12 + B callbackasm1(SB) + MOVD $774, R12 + B callbackasm1(SB) + MOVD $775, R12 + B callbackasm1(SB) + MOVD $776, R12 + B callbackasm1(SB) + MOVD $777, R12 + B callbackasm1(SB) + MOVD $778, R12 + B callbackasm1(SB) + MOVD $779, R12 + B callbackasm1(SB) + MOVD $780, R12 + B callbackasm1(SB) + MOVD $781, R12 + B callbackasm1(SB) + MOVD $782, R12 + B callbackasm1(SB) + MOVD $783, R12 + B callbackasm1(SB) + MOVD $784, R12 + B callbackasm1(SB) + MOVD $785, R12 + B callbackasm1(SB) + MOVD $786, R12 + B callbackasm1(SB) + MOVD $787, R12 + B callbackasm1(SB) + MOVD $788, R12 + B callbackasm1(SB) + MOVD $789, R12 + B callbackasm1(SB) + MOVD $790, R12 + B callbackasm1(SB) + MOVD $791, R12 + B callbackasm1(SB) + MOVD $792, R12 + B callbackasm1(SB) + MOVD $793, R12 + B callbackasm1(SB) + MOVD $794, R12 + B callbackasm1(SB) + MOVD $795, R12 + B callbackasm1(SB) + MOVD $796, R12 + B callbackasm1(SB) + MOVD $797, R12 + B callbackasm1(SB) + MOVD $798, R12 + B callbackasm1(SB) + MOVD $799, R12 + B callbackasm1(SB) + MOVD $800, R12 + B callbackasm1(SB) + MOVD $801, R12 + B callbackasm1(SB) + MOVD $802, R12 + B callbackasm1(SB) + MOVD $803, R12 + B callbackasm1(SB) + MOVD $804, R12 + B callbackasm1(SB) + MOVD $805, R12 + B callbackasm1(SB) + MOVD $806, R12 + B callbackasm1(SB) + MOVD $807, R12 + B callbackasm1(SB) + MOVD $808, R12 + B callbackasm1(SB) + MOVD $809, R12 + B callbackasm1(SB) + MOVD $810, R12 + B callbackasm1(SB) + MOVD $811, R12 + B callbackasm1(SB) + MOVD $812, R12 + B callbackasm1(SB) + MOVD $813, R12 + B callbackasm1(SB) + MOVD $814, R12 + B callbackasm1(SB) + MOVD $815, R12 + B callbackasm1(SB) + MOVD $816, R12 + B callbackasm1(SB) + MOVD $817, R12 + B callbackasm1(SB) + MOVD $818, R12 + B callbackasm1(SB) + MOVD $819, R12 + B callbackasm1(SB) + MOVD $820, R12 + B callbackasm1(SB) + MOVD $821, R12 + B callbackasm1(SB) + MOVD $822, R12 + B callbackasm1(SB) + MOVD $823, R12 + B callbackasm1(SB) + MOVD $824, R12 + B callbackasm1(SB) + MOVD $825, R12 + B callbackasm1(SB) + MOVD $826, R12 + B callbackasm1(SB) + MOVD $827, R12 + B callbackasm1(SB) + MOVD $828, R12 + B callbackasm1(SB) + MOVD $829, R12 + B callbackasm1(SB) + MOVD $830, R12 + B callbackasm1(SB) + MOVD $831, R12 + B callbackasm1(SB) + MOVD $832, R12 + B callbackasm1(SB) + MOVD $833, R12 + B callbackasm1(SB) + MOVD $834, R12 + B callbackasm1(SB) + MOVD $835, R12 + B callbackasm1(SB) + MOVD $836, R12 + B callbackasm1(SB) + MOVD $837, R12 + B callbackasm1(SB) + MOVD $838, R12 + B callbackasm1(SB) + MOVD $839, R12 + B callbackasm1(SB) + MOVD $840, R12 + B callbackasm1(SB) + MOVD $841, R12 + B callbackasm1(SB) + MOVD $842, R12 + B callbackasm1(SB) + MOVD $843, R12 + B callbackasm1(SB) + MOVD $844, R12 + B callbackasm1(SB) + MOVD $845, R12 + B callbackasm1(SB) + MOVD $846, R12 + B callbackasm1(SB) + MOVD $847, R12 + B callbackasm1(SB) + MOVD $848, R12 + B callbackasm1(SB) + MOVD $849, R12 + B callbackasm1(SB) + MOVD $850, R12 + B callbackasm1(SB) + MOVD $851, R12 + B callbackasm1(SB) + MOVD $852, R12 + B callbackasm1(SB) + MOVD $853, R12 + B callbackasm1(SB) + MOVD $854, R12 + B callbackasm1(SB) + MOVD $855, R12 + B callbackasm1(SB) + MOVD $856, R12 + B callbackasm1(SB) + MOVD $857, R12 + B callbackasm1(SB) + MOVD $858, R12 + B callbackasm1(SB) + MOVD $859, R12 + B callbackasm1(SB) + MOVD $860, R12 + B callbackasm1(SB) + MOVD $861, R12 + B callbackasm1(SB) + MOVD $862, R12 + B callbackasm1(SB) + MOVD $863, R12 + B callbackasm1(SB) + MOVD $864, R12 + B callbackasm1(SB) + MOVD $865, R12 + B callbackasm1(SB) + MOVD $866, R12 + B callbackasm1(SB) + MOVD $867, R12 + B callbackasm1(SB) + MOVD $868, R12 + B callbackasm1(SB) + MOVD $869, R12 + B callbackasm1(SB) + MOVD $870, R12 + B callbackasm1(SB) + MOVD $871, R12 + B callbackasm1(SB) + MOVD $872, R12 + B callbackasm1(SB) + MOVD $873, R12 + B callbackasm1(SB) + MOVD $874, R12 + B callbackasm1(SB) + MOVD $875, R12 + B callbackasm1(SB) + MOVD $876, R12 + B callbackasm1(SB) + MOVD $877, R12 + B callbackasm1(SB) + MOVD $878, R12 + B callbackasm1(SB) + MOVD $879, R12 + B callbackasm1(SB) + MOVD $880, R12 + B callbackasm1(SB) + MOVD $881, R12 + B callbackasm1(SB) + MOVD $882, R12 + B callbackasm1(SB) + MOVD $883, R12 + B callbackasm1(SB) + MOVD $884, R12 + B callbackasm1(SB) + MOVD $885, R12 + B callbackasm1(SB) + MOVD $886, R12 + B callbackasm1(SB) + MOVD $887, R12 + B callbackasm1(SB) + MOVD $888, R12 + B callbackasm1(SB) + MOVD $889, R12 + B callbackasm1(SB) + MOVD $890, R12 + B callbackasm1(SB) + MOVD $891, R12 + B callbackasm1(SB) + MOVD $892, R12 + B callbackasm1(SB) + MOVD $893, R12 + B callbackasm1(SB) + MOVD $894, R12 + B callbackasm1(SB) + MOVD $895, R12 + B callbackasm1(SB) + MOVD $896, R12 + B callbackasm1(SB) + MOVD $897, R12 + B callbackasm1(SB) + MOVD $898, R12 + B callbackasm1(SB) + MOVD $899, R12 + B callbackasm1(SB) + MOVD $900, R12 + B callbackasm1(SB) + MOVD $901, R12 + B callbackasm1(SB) + MOVD $902, R12 + B callbackasm1(SB) + MOVD $903, R12 + B callbackasm1(SB) + MOVD $904, R12 + B callbackasm1(SB) + MOVD $905, R12 + B callbackasm1(SB) + MOVD $906, R12 + B callbackasm1(SB) + MOVD $907, R12 + B callbackasm1(SB) + MOVD $908, R12 + B callbackasm1(SB) + MOVD $909, R12 + B callbackasm1(SB) + MOVD $910, R12 + B callbackasm1(SB) + MOVD $911, R12 + B callbackasm1(SB) + MOVD $912, R12 + B callbackasm1(SB) + MOVD $913, R12 + B callbackasm1(SB) + MOVD $914, R12 + B callbackasm1(SB) + MOVD $915, R12 + B callbackasm1(SB) + MOVD $916, R12 + B callbackasm1(SB) + MOVD $917, R12 + B callbackasm1(SB) + MOVD $918, R12 + B callbackasm1(SB) + MOVD $919, R12 + B callbackasm1(SB) + MOVD $920, R12 + B callbackasm1(SB) + MOVD $921, R12 + B callbackasm1(SB) + MOVD $922, R12 + B callbackasm1(SB) + MOVD $923, R12 + B callbackasm1(SB) + MOVD $924, R12 + B callbackasm1(SB) + MOVD $925, R12 + B callbackasm1(SB) + MOVD $926, R12 + B callbackasm1(SB) + MOVD $927, R12 + B callbackasm1(SB) + MOVD $928, R12 + B callbackasm1(SB) + MOVD $929, R12 + B callbackasm1(SB) + MOVD $930, R12 + B callbackasm1(SB) + MOVD $931, R12 + B callbackasm1(SB) + MOVD $932, R12 + B callbackasm1(SB) + MOVD $933, R12 + B callbackasm1(SB) + MOVD $934, R12 + B callbackasm1(SB) + MOVD $935, R12 + B callbackasm1(SB) + MOVD $936, R12 + B callbackasm1(SB) + MOVD $937, R12 + B callbackasm1(SB) + MOVD $938, R12 + B callbackasm1(SB) + MOVD $939, R12 + B callbackasm1(SB) + MOVD $940, R12 + B callbackasm1(SB) + MOVD $941, R12 + B callbackasm1(SB) + MOVD $942, R12 + B callbackasm1(SB) + MOVD $943, R12 + B callbackasm1(SB) + MOVD $944, R12 + B callbackasm1(SB) + MOVD $945, R12 + B callbackasm1(SB) + MOVD $946, R12 + B callbackasm1(SB) + MOVD $947, R12 + B callbackasm1(SB) + MOVD $948, R12 + B callbackasm1(SB) + MOVD $949, R12 + B callbackasm1(SB) + MOVD $950, R12 + B callbackasm1(SB) + MOVD $951, R12 + B callbackasm1(SB) + MOVD $952, R12 + B callbackasm1(SB) + MOVD $953, R12 + B callbackasm1(SB) + MOVD $954, R12 + B callbackasm1(SB) + MOVD $955, R12 + B callbackasm1(SB) + MOVD $956, R12 + B callbackasm1(SB) + MOVD $957, R12 + B callbackasm1(SB) + MOVD $958, R12 + B callbackasm1(SB) + MOVD $959, R12 + B callbackasm1(SB) + MOVD $960, R12 + B callbackasm1(SB) + MOVD $961, R12 + B callbackasm1(SB) + MOVD $962, R12 + B callbackasm1(SB) + MOVD $963, R12 + B callbackasm1(SB) + MOVD $964, R12 + B callbackasm1(SB) + MOVD $965, R12 + B callbackasm1(SB) + MOVD $966, R12 + B callbackasm1(SB) + MOVD $967, R12 + B callbackasm1(SB) + MOVD $968, R12 + B callbackasm1(SB) + MOVD $969, R12 + B callbackasm1(SB) + MOVD $970, R12 + B callbackasm1(SB) + MOVD $971, R12 + B callbackasm1(SB) + MOVD $972, R12 + B callbackasm1(SB) + MOVD $973, R12 + B callbackasm1(SB) + MOVD $974, R12 + B callbackasm1(SB) + MOVD $975, R12 + B callbackasm1(SB) + MOVD $976, R12 + B callbackasm1(SB) + MOVD $977, R12 + B callbackasm1(SB) + MOVD $978, R12 + B callbackasm1(SB) + MOVD $979, R12 + B callbackasm1(SB) + MOVD $980, R12 + B callbackasm1(SB) + MOVD $981, R12 + B callbackasm1(SB) + MOVD $982, R12 + B callbackasm1(SB) + MOVD $983, R12 + B callbackasm1(SB) + MOVD $984, R12 + B callbackasm1(SB) + MOVD $985, R12 + B callbackasm1(SB) + MOVD $986, R12 + B callbackasm1(SB) + MOVD $987, R12 + B callbackasm1(SB) + MOVD $988, R12 + B callbackasm1(SB) + MOVD $989, R12 + B callbackasm1(SB) + MOVD $990, R12 + B callbackasm1(SB) + MOVD $991, R12 + B callbackasm1(SB) + MOVD $992, R12 + B callbackasm1(SB) + MOVD $993, R12 + B callbackasm1(SB) + MOVD $994, R12 + B callbackasm1(SB) + MOVD $995, R12 + B callbackasm1(SB) + MOVD $996, R12 + B callbackasm1(SB) + MOVD $997, R12 + B callbackasm1(SB) + MOVD $998, R12 + B callbackasm1(SB) + MOVD $999, R12 + B callbackasm1(SB) + MOVD $1000, R12 + B callbackasm1(SB) + MOVD $1001, R12 + B callbackasm1(SB) + MOVD $1002, R12 + B callbackasm1(SB) + MOVD $1003, R12 + B callbackasm1(SB) + MOVD $1004, R12 + B callbackasm1(SB) + MOVD $1005, R12 + B callbackasm1(SB) + MOVD $1006, R12 + B callbackasm1(SB) + MOVD $1007, R12 + B callbackasm1(SB) + MOVD $1008, R12 + B callbackasm1(SB) + MOVD $1009, R12 + B callbackasm1(SB) + MOVD $1010, R12 + B callbackasm1(SB) + MOVD $1011, R12 + B callbackasm1(SB) + MOVD $1012, R12 + B callbackasm1(SB) + MOVD $1013, R12 + B callbackasm1(SB) + MOVD $1014, R12 + B callbackasm1(SB) + MOVD $1015, R12 + B callbackasm1(SB) + MOVD $1016, R12 + B callbackasm1(SB) + MOVD $1017, R12 + B callbackasm1(SB) + MOVD $1018, R12 + B callbackasm1(SB) + MOVD $1019, R12 + B callbackasm1(SB) + MOVD $1020, R12 + B callbackasm1(SB) + MOVD $1021, R12 + B callbackasm1(SB) + MOVD $1022, R12 + B callbackasm1(SB) + MOVD $1023, R12 + B callbackasm1(SB) + MOVD $1024, R12 + B callbackasm1(SB) + MOVD $1025, R12 + B callbackasm1(SB) + MOVD $1026, R12 + B callbackasm1(SB) + MOVD $1027, R12 + B callbackasm1(SB) + MOVD $1028, R12 + B callbackasm1(SB) + MOVD $1029, R12 + B callbackasm1(SB) + MOVD $1030, R12 + B callbackasm1(SB) + MOVD $1031, R12 + B callbackasm1(SB) + MOVD $1032, R12 + B callbackasm1(SB) + MOVD $1033, R12 + B callbackasm1(SB) + MOVD $1034, R12 + B callbackasm1(SB) + MOVD $1035, R12 + B callbackasm1(SB) + MOVD $1036, R12 + B callbackasm1(SB) + MOVD $1037, R12 + B callbackasm1(SB) + MOVD $1038, R12 + B callbackasm1(SB) + MOVD $1039, R12 + B callbackasm1(SB) + MOVD $1040, R12 + B callbackasm1(SB) + MOVD $1041, R12 + B callbackasm1(SB) + MOVD $1042, R12 + B callbackasm1(SB) + MOVD $1043, R12 + B callbackasm1(SB) + MOVD $1044, R12 + B callbackasm1(SB) + MOVD $1045, R12 + B callbackasm1(SB) + MOVD $1046, R12 + B callbackasm1(SB) + MOVD $1047, R12 + B callbackasm1(SB) + MOVD $1048, R12 + B callbackasm1(SB) + MOVD $1049, R12 + B callbackasm1(SB) + MOVD $1050, R12 + B callbackasm1(SB) + MOVD $1051, R12 + B callbackasm1(SB) + MOVD $1052, R12 + B callbackasm1(SB) + MOVD $1053, R12 + B callbackasm1(SB) + MOVD $1054, R12 + B callbackasm1(SB) + MOVD $1055, R12 + B callbackasm1(SB) + MOVD $1056, R12 + B callbackasm1(SB) + MOVD $1057, R12 + B callbackasm1(SB) + MOVD $1058, R12 + B callbackasm1(SB) + MOVD $1059, R12 + B callbackasm1(SB) + MOVD $1060, R12 + B callbackasm1(SB) + MOVD $1061, R12 + B callbackasm1(SB) + MOVD $1062, R12 + B callbackasm1(SB) + MOVD $1063, R12 + B callbackasm1(SB) + MOVD $1064, R12 + B callbackasm1(SB) + MOVD $1065, R12 + B callbackasm1(SB) + MOVD $1066, R12 + B callbackasm1(SB) + MOVD $1067, R12 + B callbackasm1(SB) + MOVD $1068, R12 + B callbackasm1(SB) + MOVD $1069, R12 + B callbackasm1(SB) + MOVD $1070, R12 + B callbackasm1(SB) + MOVD $1071, R12 + B callbackasm1(SB) + MOVD $1072, R12 + B callbackasm1(SB) + MOVD $1073, R12 + B callbackasm1(SB) + MOVD $1074, R12 + B callbackasm1(SB) + MOVD $1075, R12 + B callbackasm1(SB) + MOVD $1076, R12 + B callbackasm1(SB) + MOVD $1077, R12 + B callbackasm1(SB) + MOVD $1078, R12 + B callbackasm1(SB) + MOVD $1079, R12 + B callbackasm1(SB) + MOVD $1080, R12 + B callbackasm1(SB) + MOVD $1081, R12 + B callbackasm1(SB) + MOVD $1082, R12 + B callbackasm1(SB) + MOVD $1083, R12 + B callbackasm1(SB) + MOVD $1084, R12 + B callbackasm1(SB) + MOVD $1085, R12 + B callbackasm1(SB) + MOVD $1086, R12 + B callbackasm1(SB) + MOVD $1087, R12 + B callbackasm1(SB) + MOVD $1088, R12 + B callbackasm1(SB) + MOVD $1089, R12 + B callbackasm1(SB) + MOVD $1090, R12 + B callbackasm1(SB) + MOVD $1091, R12 + B callbackasm1(SB) + MOVD $1092, R12 + B callbackasm1(SB) + MOVD $1093, R12 + B callbackasm1(SB) + MOVD $1094, R12 + B callbackasm1(SB) + MOVD $1095, R12 + B callbackasm1(SB) + MOVD $1096, R12 + B callbackasm1(SB) + MOVD $1097, R12 + B callbackasm1(SB) + MOVD $1098, R12 + B callbackasm1(SB) + MOVD $1099, R12 + B callbackasm1(SB) + MOVD $1100, R12 + B callbackasm1(SB) + MOVD $1101, R12 + B callbackasm1(SB) + MOVD $1102, R12 + B callbackasm1(SB) + MOVD $1103, R12 + B callbackasm1(SB) + MOVD $1104, R12 + B callbackasm1(SB) + MOVD $1105, R12 + B callbackasm1(SB) + MOVD $1106, R12 + B callbackasm1(SB) + MOVD $1107, R12 + B callbackasm1(SB) + MOVD $1108, R12 + B callbackasm1(SB) + MOVD $1109, R12 + B callbackasm1(SB) + MOVD $1110, R12 + B callbackasm1(SB) + MOVD $1111, R12 + B callbackasm1(SB) + MOVD $1112, R12 + B callbackasm1(SB) + MOVD $1113, R12 + B callbackasm1(SB) + MOVD $1114, R12 + B callbackasm1(SB) + MOVD $1115, R12 + B callbackasm1(SB) + MOVD $1116, R12 + B callbackasm1(SB) + MOVD $1117, R12 + B callbackasm1(SB) + MOVD $1118, R12 + B callbackasm1(SB) + MOVD $1119, R12 + B callbackasm1(SB) + MOVD $1120, R12 + B callbackasm1(SB) + MOVD $1121, R12 + B callbackasm1(SB) + MOVD $1122, R12 + B callbackasm1(SB) + MOVD $1123, R12 + B callbackasm1(SB) + MOVD $1124, R12 + B callbackasm1(SB) + MOVD $1125, R12 + B callbackasm1(SB) + MOVD $1126, R12 + B callbackasm1(SB) + MOVD $1127, R12 + B callbackasm1(SB) + MOVD $1128, R12 + B callbackasm1(SB) + MOVD $1129, R12 + B callbackasm1(SB) + MOVD $1130, R12 + B callbackasm1(SB) + MOVD $1131, R12 + B callbackasm1(SB) + MOVD $1132, R12 + B callbackasm1(SB) + MOVD $1133, R12 + B callbackasm1(SB) + MOVD $1134, R12 + B callbackasm1(SB) + MOVD $1135, R12 + B callbackasm1(SB) + MOVD $1136, R12 + B callbackasm1(SB) + MOVD $1137, R12 + B callbackasm1(SB) + MOVD $1138, R12 + B callbackasm1(SB) + MOVD $1139, R12 + B callbackasm1(SB) + MOVD $1140, R12 + B callbackasm1(SB) + MOVD $1141, R12 + B callbackasm1(SB) + MOVD $1142, R12 + B callbackasm1(SB) + MOVD $1143, R12 + B callbackasm1(SB) + MOVD $1144, R12 + B callbackasm1(SB) + MOVD $1145, R12 + B callbackasm1(SB) + MOVD $1146, R12 + B callbackasm1(SB) + MOVD $1147, R12 + B callbackasm1(SB) + MOVD $1148, R12 + B callbackasm1(SB) + MOVD $1149, R12 + B callbackasm1(SB) + MOVD $1150, R12 + B callbackasm1(SB) + MOVD $1151, R12 + B callbackasm1(SB) + MOVD $1152, R12 + B callbackasm1(SB) + MOVD $1153, R12 + B callbackasm1(SB) + MOVD $1154, R12 + B callbackasm1(SB) + MOVD $1155, R12 + B callbackasm1(SB) + MOVD $1156, R12 + B callbackasm1(SB) + MOVD $1157, R12 + B callbackasm1(SB) + MOVD $1158, R12 + B callbackasm1(SB) + MOVD $1159, R12 + B callbackasm1(SB) + MOVD $1160, R12 + B callbackasm1(SB) + MOVD $1161, R12 + B callbackasm1(SB) + MOVD $1162, R12 + B callbackasm1(SB) + MOVD $1163, R12 + B callbackasm1(SB) + MOVD $1164, R12 + B callbackasm1(SB) + MOVD $1165, R12 + B callbackasm1(SB) + MOVD $1166, R12 + B callbackasm1(SB) + MOVD $1167, R12 + B callbackasm1(SB) + MOVD $1168, R12 + B callbackasm1(SB) + MOVD $1169, R12 + B callbackasm1(SB) + MOVD $1170, R12 + B callbackasm1(SB) + MOVD $1171, R12 + B callbackasm1(SB) + MOVD $1172, R12 + B callbackasm1(SB) + MOVD $1173, R12 + B callbackasm1(SB) + MOVD $1174, R12 + B callbackasm1(SB) + MOVD $1175, R12 + B callbackasm1(SB) + MOVD $1176, R12 + B callbackasm1(SB) + MOVD $1177, R12 + B callbackasm1(SB) + MOVD $1178, R12 + B callbackasm1(SB) + MOVD $1179, R12 + B callbackasm1(SB) + MOVD $1180, R12 + B callbackasm1(SB) + MOVD $1181, R12 + B callbackasm1(SB) + MOVD $1182, R12 + B callbackasm1(SB) + MOVD $1183, R12 + B callbackasm1(SB) + MOVD $1184, R12 + B callbackasm1(SB) + MOVD $1185, R12 + B callbackasm1(SB) + MOVD $1186, R12 + B callbackasm1(SB) + MOVD $1187, R12 + B callbackasm1(SB) + MOVD $1188, R12 + B callbackasm1(SB) + MOVD $1189, R12 + B callbackasm1(SB) + MOVD $1190, R12 + B callbackasm1(SB) + MOVD $1191, R12 + B callbackasm1(SB) + MOVD $1192, R12 + B callbackasm1(SB) + MOVD $1193, R12 + B callbackasm1(SB) + MOVD $1194, R12 + B callbackasm1(SB) + MOVD $1195, R12 + B callbackasm1(SB) + MOVD $1196, R12 + B callbackasm1(SB) + MOVD $1197, R12 + B callbackasm1(SB) + MOVD $1198, R12 + B callbackasm1(SB) + MOVD $1199, R12 + B callbackasm1(SB) + MOVD $1200, R12 + B callbackasm1(SB) + MOVD $1201, R12 + B callbackasm1(SB) + MOVD $1202, R12 + B callbackasm1(SB) + MOVD $1203, R12 + B callbackasm1(SB) + MOVD $1204, R12 + B callbackasm1(SB) + MOVD $1205, R12 + B callbackasm1(SB) + MOVD $1206, R12 + B callbackasm1(SB) + MOVD $1207, R12 + B callbackasm1(SB) + MOVD $1208, R12 + B callbackasm1(SB) + MOVD $1209, R12 + B callbackasm1(SB) + MOVD $1210, R12 + B callbackasm1(SB) + MOVD $1211, R12 + B callbackasm1(SB) + MOVD $1212, R12 + B callbackasm1(SB) + MOVD $1213, R12 + B callbackasm1(SB) + MOVD $1214, R12 + B callbackasm1(SB) + MOVD $1215, R12 + B callbackasm1(SB) + MOVD $1216, R12 + B callbackasm1(SB) + MOVD $1217, R12 + B callbackasm1(SB) + MOVD $1218, R12 + B callbackasm1(SB) + MOVD $1219, R12 + B callbackasm1(SB) + MOVD $1220, R12 + B callbackasm1(SB) + MOVD $1221, R12 + B callbackasm1(SB) + MOVD $1222, R12 + B callbackasm1(SB) + MOVD $1223, R12 + B callbackasm1(SB) + MOVD $1224, R12 + B callbackasm1(SB) + MOVD $1225, R12 + B callbackasm1(SB) + MOVD $1226, R12 + B callbackasm1(SB) + MOVD $1227, R12 + B callbackasm1(SB) + MOVD $1228, R12 + B callbackasm1(SB) + MOVD $1229, R12 + B callbackasm1(SB) + MOVD $1230, R12 + B callbackasm1(SB) + MOVD $1231, R12 + B callbackasm1(SB) + MOVD $1232, R12 + B callbackasm1(SB) + MOVD $1233, R12 + B callbackasm1(SB) + MOVD $1234, R12 + B callbackasm1(SB) + MOVD $1235, R12 + B callbackasm1(SB) + MOVD $1236, R12 + B callbackasm1(SB) + MOVD $1237, R12 + B callbackasm1(SB) + MOVD $1238, R12 + B callbackasm1(SB) + MOVD $1239, R12 + B callbackasm1(SB) + MOVD $1240, R12 + B callbackasm1(SB) + MOVD $1241, R12 + B callbackasm1(SB) + MOVD $1242, R12 + B callbackasm1(SB) + MOVD $1243, R12 + B callbackasm1(SB) + MOVD $1244, R12 + B callbackasm1(SB) + MOVD $1245, R12 + B callbackasm1(SB) + MOVD $1246, R12 + B callbackasm1(SB) + MOVD $1247, R12 + B callbackasm1(SB) + MOVD $1248, R12 + B callbackasm1(SB) + MOVD $1249, R12 + B callbackasm1(SB) + MOVD $1250, R12 + B callbackasm1(SB) + MOVD $1251, R12 + B callbackasm1(SB) + MOVD $1252, R12 + B callbackasm1(SB) + MOVD $1253, R12 + B callbackasm1(SB) + MOVD $1254, R12 + B callbackasm1(SB) + MOVD $1255, R12 + B callbackasm1(SB) + MOVD $1256, R12 + B callbackasm1(SB) + MOVD $1257, R12 + B callbackasm1(SB) + MOVD $1258, R12 + B callbackasm1(SB) + MOVD $1259, R12 + B callbackasm1(SB) + MOVD $1260, R12 + B callbackasm1(SB) + MOVD $1261, R12 + B callbackasm1(SB) + MOVD $1262, R12 + B callbackasm1(SB) + MOVD $1263, R12 + B callbackasm1(SB) + MOVD $1264, R12 + B callbackasm1(SB) + MOVD $1265, R12 + B callbackasm1(SB) + MOVD $1266, R12 + B callbackasm1(SB) + MOVD $1267, R12 + B callbackasm1(SB) + MOVD $1268, R12 + B callbackasm1(SB) + MOVD $1269, R12 + B callbackasm1(SB) + MOVD $1270, R12 + B callbackasm1(SB) + MOVD $1271, R12 + B callbackasm1(SB) + MOVD $1272, R12 + B callbackasm1(SB) + MOVD $1273, R12 + B callbackasm1(SB) + MOVD $1274, R12 + B callbackasm1(SB) + MOVD $1275, R12 + B callbackasm1(SB) + MOVD $1276, R12 + B callbackasm1(SB) + MOVD $1277, R12 + B callbackasm1(SB) + MOVD $1278, R12 + B callbackasm1(SB) + MOVD $1279, R12 + B callbackasm1(SB) + MOVD $1280, R12 + B callbackasm1(SB) + MOVD $1281, R12 + B callbackasm1(SB) + MOVD $1282, R12 + B callbackasm1(SB) + MOVD $1283, R12 + B callbackasm1(SB) + MOVD $1284, R12 + B callbackasm1(SB) + MOVD $1285, R12 + B callbackasm1(SB) + MOVD $1286, R12 + B callbackasm1(SB) + MOVD $1287, R12 + B callbackasm1(SB) + MOVD $1288, R12 + B callbackasm1(SB) + MOVD $1289, R12 + B callbackasm1(SB) + MOVD $1290, R12 + B callbackasm1(SB) + MOVD $1291, R12 + B callbackasm1(SB) + MOVD $1292, R12 + B callbackasm1(SB) + MOVD $1293, R12 + B callbackasm1(SB) + MOVD $1294, R12 + B callbackasm1(SB) + MOVD $1295, R12 + B callbackasm1(SB) + MOVD $1296, R12 + B callbackasm1(SB) + MOVD $1297, R12 + B callbackasm1(SB) + MOVD $1298, R12 + B callbackasm1(SB) + MOVD $1299, R12 + B callbackasm1(SB) + MOVD $1300, R12 + B callbackasm1(SB) + MOVD $1301, R12 + B callbackasm1(SB) + MOVD $1302, R12 + B callbackasm1(SB) + MOVD $1303, R12 + B callbackasm1(SB) + MOVD $1304, R12 + B callbackasm1(SB) + MOVD $1305, R12 + B callbackasm1(SB) + MOVD $1306, R12 + B callbackasm1(SB) + MOVD $1307, R12 + B callbackasm1(SB) + MOVD $1308, R12 + B callbackasm1(SB) + MOVD $1309, R12 + B callbackasm1(SB) + MOVD $1310, R12 + B callbackasm1(SB) + MOVD $1311, R12 + B callbackasm1(SB) + MOVD $1312, R12 + B callbackasm1(SB) + MOVD $1313, R12 + B callbackasm1(SB) + MOVD $1314, R12 + B callbackasm1(SB) + MOVD $1315, R12 + B callbackasm1(SB) + MOVD $1316, R12 + B callbackasm1(SB) + MOVD $1317, R12 + B callbackasm1(SB) + MOVD $1318, R12 + B callbackasm1(SB) + MOVD $1319, R12 + B callbackasm1(SB) + MOVD $1320, R12 + B callbackasm1(SB) + MOVD $1321, R12 + B callbackasm1(SB) + MOVD $1322, R12 + B callbackasm1(SB) + MOVD $1323, R12 + B callbackasm1(SB) + MOVD $1324, R12 + B callbackasm1(SB) + MOVD $1325, R12 + B callbackasm1(SB) + MOVD $1326, R12 + B callbackasm1(SB) + MOVD $1327, R12 + B callbackasm1(SB) + MOVD $1328, R12 + B callbackasm1(SB) + MOVD $1329, R12 + B callbackasm1(SB) + MOVD $1330, R12 + B callbackasm1(SB) + MOVD $1331, R12 + B callbackasm1(SB) + MOVD $1332, R12 + B callbackasm1(SB) + MOVD $1333, R12 + B callbackasm1(SB) + MOVD $1334, R12 + B callbackasm1(SB) + MOVD $1335, R12 + B callbackasm1(SB) + MOVD $1336, R12 + B callbackasm1(SB) + MOVD $1337, R12 + B callbackasm1(SB) + MOVD $1338, R12 + B callbackasm1(SB) + MOVD $1339, R12 + B callbackasm1(SB) + MOVD $1340, R12 + B callbackasm1(SB) + MOVD $1341, R12 + B callbackasm1(SB) + MOVD $1342, R12 + B callbackasm1(SB) + MOVD $1343, R12 + B callbackasm1(SB) + MOVD $1344, R12 + B callbackasm1(SB) + MOVD $1345, R12 + B callbackasm1(SB) + MOVD $1346, R12 + B callbackasm1(SB) + MOVD $1347, R12 + B callbackasm1(SB) + MOVD $1348, R12 + B callbackasm1(SB) + MOVD $1349, R12 + B callbackasm1(SB) + MOVD $1350, R12 + B callbackasm1(SB) + MOVD $1351, R12 + B callbackasm1(SB) + MOVD $1352, R12 + B callbackasm1(SB) + MOVD $1353, R12 + B callbackasm1(SB) + MOVD $1354, R12 + B callbackasm1(SB) + MOVD $1355, R12 + B callbackasm1(SB) + MOVD $1356, R12 + B callbackasm1(SB) + MOVD $1357, R12 + B callbackasm1(SB) + MOVD $1358, R12 + B callbackasm1(SB) + MOVD $1359, R12 + B callbackasm1(SB) + MOVD $1360, R12 + B callbackasm1(SB) + MOVD $1361, R12 + B callbackasm1(SB) + MOVD $1362, R12 + B callbackasm1(SB) + MOVD $1363, R12 + B callbackasm1(SB) + MOVD $1364, R12 + B callbackasm1(SB) + MOVD $1365, R12 + B callbackasm1(SB) + MOVD $1366, R12 + B callbackasm1(SB) + MOVD $1367, R12 + B callbackasm1(SB) + MOVD $1368, R12 + B callbackasm1(SB) + MOVD $1369, R12 + B callbackasm1(SB) + MOVD $1370, R12 + B callbackasm1(SB) + MOVD $1371, R12 + B callbackasm1(SB) + MOVD $1372, R12 + B callbackasm1(SB) + MOVD $1373, R12 + B callbackasm1(SB) + MOVD $1374, R12 + B callbackasm1(SB) + MOVD $1375, R12 + B callbackasm1(SB) + MOVD $1376, R12 + B callbackasm1(SB) + MOVD $1377, R12 + B callbackasm1(SB) + MOVD $1378, R12 + B callbackasm1(SB) + MOVD $1379, R12 + B callbackasm1(SB) + MOVD $1380, R12 + B callbackasm1(SB) + MOVD $1381, R12 + B callbackasm1(SB) + MOVD $1382, R12 + B callbackasm1(SB) + MOVD $1383, R12 + B callbackasm1(SB) + MOVD $1384, R12 + B callbackasm1(SB) + MOVD $1385, R12 + B callbackasm1(SB) + MOVD $1386, R12 + B callbackasm1(SB) + MOVD $1387, R12 + B callbackasm1(SB) + MOVD $1388, R12 + B callbackasm1(SB) + MOVD $1389, R12 + B callbackasm1(SB) + MOVD $1390, R12 + B callbackasm1(SB) + MOVD $1391, R12 + B callbackasm1(SB) + MOVD $1392, R12 + B callbackasm1(SB) + MOVD $1393, R12 + B callbackasm1(SB) + MOVD $1394, R12 + B callbackasm1(SB) + MOVD $1395, R12 + B callbackasm1(SB) + MOVD $1396, R12 + B callbackasm1(SB) + MOVD $1397, R12 + B callbackasm1(SB) + MOVD $1398, R12 + B callbackasm1(SB) + MOVD $1399, R12 + B callbackasm1(SB) + MOVD $1400, R12 + B callbackasm1(SB) + MOVD $1401, R12 + B callbackasm1(SB) + MOVD $1402, R12 + B callbackasm1(SB) + MOVD $1403, R12 + B callbackasm1(SB) + MOVD $1404, R12 + B callbackasm1(SB) + MOVD $1405, R12 + B callbackasm1(SB) + MOVD $1406, R12 + B callbackasm1(SB) + MOVD $1407, R12 + B callbackasm1(SB) + MOVD $1408, R12 + B callbackasm1(SB) + MOVD $1409, R12 + B callbackasm1(SB) + MOVD $1410, R12 + B callbackasm1(SB) + MOVD $1411, R12 + B callbackasm1(SB) + MOVD $1412, R12 + B callbackasm1(SB) + MOVD $1413, R12 + B callbackasm1(SB) + MOVD $1414, R12 + B callbackasm1(SB) + MOVD $1415, R12 + B callbackasm1(SB) + MOVD $1416, R12 + B callbackasm1(SB) + MOVD $1417, R12 + B callbackasm1(SB) + MOVD $1418, R12 + B callbackasm1(SB) + MOVD $1419, R12 + B callbackasm1(SB) + MOVD $1420, R12 + B callbackasm1(SB) + MOVD $1421, R12 + B callbackasm1(SB) + MOVD $1422, R12 + B callbackasm1(SB) + MOVD $1423, R12 + B callbackasm1(SB) + MOVD $1424, R12 + B callbackasm1(SB) + MOVD $1425, R12 + B callbackasm1(SB) + MOVD $1426, R12 + B callbackasm1(SB) + MOVD $1427, R12 + B callbackasm1(SB) + MOVD $1428, R12 + B callbackasm1(SB) + MOVD $1429, R12 + B callbackasm1(SB) + MOVD $1430, R12 + B callbackasm1(SB) + MOVD $1431, R12 + B callbackasm1(SB) + MOVD $1432, R12 + B callbackasm1(SB) + MOVD $1433, R12 + B callbackasm1(SB) + MOVD $1434, R12 + B callbackasm1(SB) + MOVD $1435, R12 + B callbackasm1(SB) + MOVD $1436, R12 + B callbackasm1(SB) + MOVD $1437, R12 + B callbackasm1(SB) + MOVD $1438, R12 + B callbackasm1(SB) + MOVD $1439, R12 + B callbackasm1(SB) + MOVD $1440, R12 + B callbackasm1(SB) + MOVD $1441, R12 + B callbackasm1(SB) + MOVD $1442, R12 + B callbackasm1(SB) + MOVD $1443, R12 + B callbackasm1(SB) + MOVD $1444, R12 + B callbackasm1(SB) + MOVD $1445, R12 + B callbackasm1(SB) + MOVD $1446, R12 + B callbackasm1(SB) + MOVD $1447, R12 + B callbackasm1(SB) + MOVD $1448, R12 + B callbackasm1(SB) + MOVD $1449, R12 + B callbackasm1(SB) + MOVD $1450, R12 + B callbackasm1(SB) + MOVD $1451, R12 + B callbackasm1(SB) + MOVD $1452, R12 + B callbackasm1(SB) + MOVD $1453, R12 + B callbackasm1(SB) + MOVD $1454, R12 + B callbackasm1(SB) + MOVD $1455, R12 + B callbackasm1(SB) + MOVD $1456, R12 + B callbackasm1(SB) + MOVD $1457, R12 + B callbackasm1(SB) + MOVD $1458, R12 + B callbackasm1(SB) + MOVD $1459, R12 + B callbackasm1(SB) + MOVD $1460, R12 + B callbackasm1(SB) + MOVD $1461, R12 + B callbackasm1(SB) + MOVD $1462, R12 + B callbackasm1(SB) + MOVD $1463, R12 + B callbackasm1(SB) + MOVD $1464, R12 + B callbackasm1(SB) + MOVD $1465, R12 + B callbackasm1(SB) + MOVD $1466, R12 + B callbackasm1(SB) + MOVD $1467, R12 + B callbackasm1(SB) + MOVD $1468, R12 + B callbackasm1(SB) + MOVD $1469, R12 + B callbackasm1(SB) + MOVD $1470, R12 + B callbackasm1(SB) + MOVD $1471, R12 + B callbackasm1(SB) + MOVD $1472, R12 + B callbackasm1(SB) + MOVD $1473, R12 + B callbackasm1(SB) + MOVD $1474, R12 + B callbackasm1(SB) + MOVD $1475, R12 + B callbackasm1(SB) + MOVD $1476, R12 + B callbackasm1(SB) + MOVD $1477, R12 + B callbackasm1(SB) + MOVD $1478, R12 + B callbackasm1(SB) + MOVD $1479, R12 + B callbackasm1(SB) + MOVD $1480, R12 + B callbackasm1(SB) + MOVD $1481, R12 + B callbackasm1(SB) + MOVD $1482, R12 + B callbackasm1(SB) + MOVD $1483, R12 + B callbackasm1(SB) + MOVD $1484, R12 + B callbackasm1(SB) + MOVD $1485, R12 + B callbackasm1(SB) + MOVD $1486, R12 + B callbackasm1(SB) + MOVD $1487, R12 + B callbackasm1(SB) + MOVD $1488, R12 + B callbackasm1(SB) + MOVD $1489, R12 + B callbackasm1(SB) + MOVD $1490, R12 + B callbackasm1(SB) + MOVD $1491, R12 + B callbackasm1(SB) + MOVD $1492, R12 + B callbackasm1(SB) + MOVD $1493, R12 + B callbackasm1(SB) + MOVD $1494, R12 + B callbackasm1(SB) + MOVD $1495, R12 + B callbackasm1(SB) + MOVD $1496, R12 + B callbackasm1(SB) + MOVD $1497, R12 + B callbackasm1(SB) + MOVD $1498, R12 + B callbackasm1(SB) + MOVD $1499, R12 + B callbackasm1(SB) + MOVD $1500, R12 + B callbackasm1(SB) + MOVD $1501, R12 + B callbackasm1(SB) + MOVD $1502, R12 + B callbackasm1(SB) + MOVD $1503, R12 + B callbackasm1(SB) + MOVD $1504, R12 + B callbackasm1(SB) + MOVD $1505, R12 + B callbackasm1(SB) + MOVD $1506, R12 + B callbackasm1(SB) + MOVD $1507, R12 + B callbackasm1(SB) + MOVD $1508, R12 + B callbackasm1(SB) + MOVD $1509, R12 + B callbackasm1(SB) + MOVD $1510, R12 + B callbackasm1(SB) + MOVD $1511, R12 + B callbackasm1(SB) + MOVD $1512, R12 + B callbackasm1(SB) + MOVD $1513, R12 + B callbackasm1(SB) + MOVD $1514, R12 + B callbackasm1(SB) + MOVD $1515, R12 + B callbackasm1(SB) + MOVD $1516, R12 + B callbackasm1(SB) + MOVD $1517, R12 + B callbackasm1(SB) + MOVD $1518, R12 + B callbackasm1(SB) + MOVD $1519, R12 + B callbackasm1(SB) + MOVD $1520, R12 + B callbackasm1(SB) + MOVD $1521, R12 + B callbackasm1(SB) + MOVD $1522, R12 + B callbackasm1(SB) + MOVD $1523, R12 + B callbackasm1(SB) + MOVD $1524, R12 + B callbackasm1(SB) + MOVD $1525, R12 + B callbackasm1(SB) + MOVD $1526, R12 + B callbackasm1(SB) + MOVD $1527, R12 + B callbackasm1(SB) + MOVD $1528, R12 + B callbackasm1(SB) + MOVD $1529, R12 + B callbackasm1(SB) + MOVD $1530, R12 + B callbackasm1(SB) + MOVD $1531, R12 + B callbackasm1(SB) + MOVD $1532, R12 + B callbackasm1(SB) + MOVD $1533, R12 + B callbackasm1(SB) + MOVD $1534, R12 + B callbackasm1(SB) + MOVD $1535, R12 + B callbackasm1(SB) + MOVD $1536, R12 + B callbackasm1(SB) + MOVD $1537, R12 + B callbackasm1(SB) + MOVD $1538, R12 + B callbackasm1(SB) + MOVD $1539, R12 + B callbackasm1(SB) + MOVD $1540, R12 + B callbackasm1(SB) + MOVD $1541, R12 + B callbackasm1(SB) + MOVD $1542, R12 + B callbackasm1(SB) + MOVD $1543, R12 + B callbackasm1(SB) + MOVD $1544, R12 + B callbackasm1(SB) + MOVD $1545, R12 + B callbackasm1(SB) + MOVD $1546, R12 + B callbackasm1(SB) + MOVD $1547, R12 + B callbackasm1(SB) + MOVD $1548, R12 + B callbackasm1(SB) + MOVD $1549, R12 + B callbackasm1(SB) + MOVD $1550, R12 + B callbackasm1(SB) + MOVD $1551, R12 + B callbackasm1(SB) + MOVD $1552, R12 + B callbackasm1(SB) + MOVD $1553, R12 + B callbackasm1(SB) + MOVD $1554, R12 + B callbackasm1(SB) + MOVD $1555, R12 + B callbackasm1(SB) + MOVD $1556, R12 + B callbackasm1(SB) + MOVD $1557, R12 + B callbackasm1(SB) + MOVD $1558, R12 + B callbackasm1(SB) + MOVD $1559, R12 + B callbackasm1(SB) + MOVD $1560, R12 + B callbackasm1(SB) + MOVD $1561, R12 + B callbackasm1(SB) + MOVD $1562, R12 + B callbackasm1(SB) + MOVD $1563, R12 + B callbackasm1(SB) + MOVD $1564, R12 + B callbackasm1(SB) + MOVD $1565, R12 + B callbackasm1(SB) + MOVD $1566, R12 + B callbackasm1(SB) + MOVD $1567, R12 + B callbackasm1(SB) + MOVD $1568, R12 + B callbackasm1(SB) + MOVD $1569, R12 + B callbackasm1(SB) + MOVD $1570, R12 + B callbackasm1(SB) + MOVD $1571, R12 + B callbackasm1(SB) + MOVD $1572, R12 + B callbackasm1(SB) + MOVD $1573, R12 + B callbackasm1(SB) + MOVD $1574, R12 + B callbackasm1(SB) + MOVD $1575, R12 + B callbackasm1(SB) + MOVD $1576, R12 + B callbackasm1(SB) + MOVD $1577, R12 + B callbackasm1(SB) + MOVD $1578, R12 + B callbackasm1(SB) + MOVD $1579, R12 + B callbackasm1(SB) + MOVD $1580, R12 + B callbackasm1(SB) + MOVD $1581, R12 + B callbackasm1(SB) + MOVD $1582, R12 + B callbackasm1(SB) + MOVD $1583, R12 + B callbackasm1(SB) + MOVD $1584, R12 + B callbackasm1(SB) + MOVD $1585, R12 + B callbackasm1(SB) + MOVD $1586, R12 + B callbackasm1(SB) + MOVD $1587, R12 + B callbackasm1(SB) + MOVD $1588, R12 + B callbackasm1(SB) + MOVD $1589, R12 + B callbackasm1(SB) + MOVD $1590, R12 + B callbackasm1(SB) + MOVD $1591, R12 + B callbackasm1(SB) + MOVD $1592, R12 + B callbackasm1(SB) + MOVD $1593, R12 + B callbackasm1(SB) + MOVD $1594, R12 + B callbackasm1(SB) + MOVD $1595, R12 + B callbackasm1(SB) + MOVD $1596, R12 + B callbackasm1(SB) + MOVD $1597, R12 + B callbackasm1(SB) + MOVD $1598, R12 + B callbackasm1(SB) + MOVD $1599, R12 + B callbackasm1(SB) + MOVD $1600, R12 + B callbackasm1(SB) + MOVD $1601, R12 + B callbackasm1(SB) + MOVD $1602, R12 + B callbackasm1(SB) + MOVD $1603, R12 + B callbackasm1(SB) + MOVD $1604, R12 + B callbackasm1(SB) + MOVD $1605, R12 + B callbackasm1(SB) + MOVD $1606, R12 + B callbackasm1(SB) + MOVD $1607, R12 + B callbackasm1(SB) + MOVD $1608, R12 + B callbackasm1(SB) + MOVD $1609, R12 + B callbackasm1(SB) + MOVD $1610, R12 + B callbackasm1(SB) + MOVD $1611, R12 + B callbackasm1(SB) + MOVD $1612, R12 + B callbackasm1(SB) + MOVD $1613, R12 + B callbackasm1(SB) + MOVD $1614, R12 + B callbackasm1(SB) + MOVD $1615, R12 + B callbackasm1(SB) + MOVD $1616, R12 + B callbackasm1(SB) + MOVD $1617, R12 + B callbackasm1(SB) + MOVD $1618, R12 + B callbackasm1(SB) + MOVD $1619, R12 + B callbackasm1(SB) + MOVD $1620, R12 + B callbackasm1(SB) + MOVD $1621, R12 + B callbackasm1(SB) + MOVD $1622, R12 + B callbackasm1(SB) + MOVD $1623, R12 + B callbackasm1(SB) + MOVD $1624, R12 + B callbackasm1(SB) + MOVD $1625, R12 + B callbackasm1(SB) + MOVD $1626, R12 + B callbackasm1(SB) + MOVD $1627, R12 + B callbackasm1(SB) + MOVD $1628, R12 + B callbackasm1(SB) + MOVD $1629, R12 + B callbackasm1(SB) + MOVD $1630, R12 + B callbackasm1(SB) + MOVD $1631, R12 + B callbackasm1(SB) + MOVD $1632, R12 + B callbackasm1(SB) + MOVD $1633, R12 + B callbackasm1(SB) + MOVD $1634, R12 + B callbackasm1(SB) + MOVD $1635, R12 + B callbackasm1(SB) + MOVD $1636, R12 + B callbackasm1(SB) + MOVD $1637, R12 + B callbackasm1(SB) + MOVD $1638, R12 + B callbackasm1(SB) + MOVD $1639, R12 + B callbackasm1(SB) + MOVD $1640, R12 + B callbackasm1(SB) + MOVD $1641, R12 + B callbackasm1(SB) + MOVD $1642, R12 + B callbackasm1(SB) + MOVD $1643, R12 + B callbackasm1(SB) + MOVD $1644, R12 + B callbackasm1(SB) + MOVD $1645, R12 + B callbackasm1(SB) + MOVD $1646, R12 + B callbackasm1(SB) + MOVD $1647, R12 + B callbackasm1(SB) + MOVD $1648, R12 + B callbackasm1(SB) + MOVD $1649, R12 + B callbackasm1(SB) + MOVD $1650, R12 + B callbackasm1(SB) + MOVD $1651, R12 + B callbackasm1(SB) + MOVD $1652, R12 + B callbackasm1(SB) + MOVD $1653, R12 + B callbackasm1(SB) + MOVD $1654, R12 + B callbackasm1(SB) + MOVD $1655, R12 + B callbackasm1(SB) + MOVD $1656, R12 + B callbackasm1(SB) + MOVD $1657, R12 + B callbackasm1(SB) + MOVD $1658, R12 + B callbackasm1(SB) + MOVD $1659, R12 + B callbackasm1(SB) + MOVD $1660, R12 + B callbackasm1(SB) + MOVD $1661, R12 + B callbackasm1(SB) + MOVD $1662, R12 + B callbackasm1(SB) + MOVD $1663, R12 + B callbackasm1(SB) + MOVD $1664, R12 + B callbackasm1(SB) + MOVD $1665, R12 + B callbackasm1(SB) + MOVD $1666, R12 + B callbackasm1(SB) + MOVD $1667, R12 + B callbackasm1(SB) + MOVD $1668, R12 + B callbackasm1(SB) + MOVD $1669, R12 + B callbackasm1(SB) + MOVD $1670, R12 + B callbackasm1(SB) + MOVD $1671, R12 + B callbackasm1(SB) + MOVD $1672, R12 + B callbackasm1(SB) + MOVD $1673, R12 + B callbackasm1(SB) + MOVD $1674, R12 + B callbackasm1(SB) + MOVD $1675, R12 + B callbackasm1(SB) + MOVD $1676, R12 + B callbackasm1(SB) + MOVD $1677, R12 + B callbackasm1(SB) + MOVD $1678, R12 + B callbackasm1(SB) + MOVD $1679, R12 + B callbackasm1(SB) + MOVD $1680, R12 + B callbackasm1(SB) + MOVD $1681, R12 + B callbackasm1(SB) + MOVD $1682, R12 + B callbackasm1(SB) + MOVD $1683, R12 + B callbackasm1(SB) + MOVD $1684, R12 + B callbackasm1(SB) + MOVD $1685, R12 + B callbackasm1(SB) + MOVD $1686, R12 + B callbackasm1(SB) + MOVD $1687, R12 + B callbackasm1(SB) + MOVD $1688, R12 + B callbackasm1(SB) + MOVD $1689, R12 + B callbackasm1(SB) + MOVD $1690, R12 + B callbackasm1(SB) + MOVD $1691, R12 + B callbackasm1(SB) + MOVD $1692, R12 + B callbackasm1(SB) + MOVD $1693, R12 + B callbackasm1(SB) + MOVD $1694, R12 + B callbackasm1(SB) + MOVD $1695, R12 + B callbackasm1(SB) + MOVD $1696, R12 + B callbackasm1(SB) + MOVD $1697, R12 + B callbackasm1(SB) + MOVD $1698, R12 + B callbackasm1(SB) + MOVD $1699, R12 + B callbackasm1(SB) + MOVD $1700, R12 + B callbackasm1(SB) + MOVD $1701, R12 + B callbackasm1(SB) + MOVD $1702, R12 + B callbackasm1(SB) + MOVD $1703, R12 + B callbackasm1(SB) + MOVD $1704, R12 + B callbackasm1(SB) + MOVD $1705, R12 + B callbackasm1(SB) + MOVD $1706, R12 + B callbackasm1(SB) + MOVD $1707, R12 + B callbackasm1(SB) + MOVD $1708, R12 + B callbackasm1(SB) + MOVD $1709, R12 + B callbackasm1(SB) + MOVD $1710, R12 + B callbackasm1(SB) + MOVD $1711, R12 + B callbackasm1(SB) + MOVD $1712, R12 + B callbackasm1(SB) + MOVD $1713, R12 + B callbackasm1(SB) + MOVD $1714, R12 + B callbackasm1(SB) + MOVD $1715, R12 + B callbackasm1(SB) + MOVD $1716, R12 + B callbackasm1(SB) + MOVD $1717, R12 + B callbackasm1(SB) + MOVD $1718, R12 + B callbackasm1(SB) + MOVD $1719, R12 + B callbackasm1(SB) + MOVD $1720, R12 + B callbackasm1(SB) + MOVD $1721, R12 + B callbackasm1(SB) + MOVD $1722, R12 + B callbackasm1(SB) + MOVD $1723, R12 + B callbackasm1(SB) + MOVD $1724, R12 + B callbackasm1(SB) + MOVD $1725, R12 + B callbackasm1(SB) + MOVD $1726, R12 + B callbackasm1(SB) + MOVD $1727, R12 + B callbackasm1(SB) + MOVD $1728, R12 + B callbackasm1(SB) + MOVD $1729, R12 + B callbackasm1(SB) + MOVD $1730, R12 + B callbackasm1(SB) + MOVD $1731, R12 + B callbackasm1(SB) + MOVD $1732, R12 + B callbackasm1(SB) + MOVD $1733, R12 + B callbackasm1(SB) + MOVD $1734, R12 + B callbackasm1(SB) + MOVD $1735, R12 + B callbackasm1(SB) + MOVD $1736, R12 + B callbackasm1(SB) + MOVD $1737, R12 + B callbackasm1(SB) + MOVD $1738, R12 + B callbackasm1(SB) + MOVD $1739, R12 + B callbackasm1(SB) + MOVD $1740, R12 + B callbackasm1(SB) + MOVD $1741, R12 + B callbackasm1(SB) + MOVD $1742, R12 + B callbackasm1(SB) + MOVD $1743, R12 + B callbackasm1(SB) + MOVD $1744, R12 + B callbackasm1(SB) + MOVD $1745, R12 + B callbackasm1(SB) + MOVD $1746, R12 + B callbackasm1(SB) + MOVD $1747, R12 + B callbackasm1(SB) + MOVD $1748, R12 + B callbackasm1(SB) + MOVD $1749, R12 + B callbackasm1(SB) + MOVD $1750, R12 + B callbackasm1(SB) + MOVD $1751, R12 + B callbackasm1(SB) + MOVD $1752, R12 + B callbackasm1(SB) + MOVD $1753, R12 + B callbackasm1(SB) + MOVD $1754, R12 + B callbackasm1(SB) + MOVD $1755, R12 + B callbackasm1(SB) + MOVD $1756, R12 + B callbackasm1(SB) + MOVD $1757, R12 + B callbackasm1(SB) + MOVD $1758, R12 + B callbackasm1(SB) + MOVD $1759, R12 + B callbackasm1(SB) + MOVD $1760, R12 + B callbackasm1(SB) + MOVD $1761, R12 + B callbackasm1(SB) + MOVD $1762, R12 + B callbackasm1(SB) + MOVD $1763, R12 + B callbackasm1(SB) + MOVD $1764, R12 + B callbackasm1(SB) + MOVD $1765, R12 + B callbackasm1(SB) + MOVD $1766, R12 + B callbackasm1(SB) + MOVD $1767, R12 + B callbackasm1(SB) + MOVD $1768, R12 + B callbackasm1(SB) + MOVD $1769, R12 + B callbackasm1(SB) + MOVD $1770, R12 + B callbackasm1(SB) + MOVD $1771, R12 + B callbackasm1(SB) + MOVD $1772, R12 + B callbackasm1(SB) + MOVD $1773, R12 + B callbackasm1(SB) + MOVD $1774, R12 + B callbackasm1(SB) + MOVD $1775, R12 + B callbackasm1(SB) + MOVD $1776, R12 + B callbackasm1(SB) + MOVD $1777, R12 + B callbackasm1(SB) + MOVD $1778, R12 + B callbackasm1(SB) + MOVD $1779, R12 + B callbackasm1(SB) + MOVD $1780, R12 + B callbackasm1(SB) + MOVD $1781, R12 + B callbackasm1(SB) + MOVD $1782, R12 + B callbackasm1(SB) + MOVD $1783, R12 + B callbackasm1(SB) + MOVD $1784, R12 + B callbackasm1(SB) + MOVD $1785, R12 + B callbackasm1(SB) + MOVD $1786, R12 + B callbackasm1(SB) + MOVD $1787, R12 + B callbackasm1(SB) + MOVD $1788, R12 + B callbackasm1(SB) + MOVD $1789, R12 + B callbackasm1(SB) + MOVD $1790, R12 + B callbackasm1(SB) + MOVD $1791, R12 + B callbackasm1(SB) + MOVD $1792, R12 + B callbackasm1(SB) + MOVD $1793, R12 + B callbackasm1(SB) + MOVD $1794, R12 + B callbackasm1(SB) + MOVD $1795, R12 + B callbackasm1(SB) + MOVD $1796, R12 + B callbackasm1(SB) + MOVD $1797, R12 + B callbackasm1(SB) + MOVD $1798, R12 + B callbackasm1(SB) + MOVD $1799, R12 + B callbackasm1(SB) + MOVD $1800, R12 + B callbackasm1(SB) + MOVD $1801, R12 + B callbackasm1(SB) + MOVD $1802, R12 + B callbackasm1(SB) + MOVD $1803, R12 + B callbackasm1(SB) + MOVD $1804, R12 + B callbackasm1(SB) + MOVD $1805, R12 + B callbackasm1(SB) + MOVD $1806, R12 + B callbackasm1(SB) + MOVD $1807, R12 + B callbackasm1(SB) + MOVD $1808, R12 + B callbackasm1(SB) + MOVD $1809, R12 + B callbackasm1(SB) + MOVD $1810, R12 + B callbackasm1(SB) + MOVD $1811, R12 + B callbackasm1(SB) + MOVD $1812, R12 + B callbackasm1(SB) + MOVD $1813, R12 + B callbackasm1(SB) + MOVD $1814, R12 + B callbackasm1(SB) + MOVD $1815, R12 + B callbackasm1(SB) + MOVD $1816, R12 + B callbackasm1(SB) + MOVD $1817, R12 + B callbackasm1(SB) + MOVD $1818, R12 + B callbackasm1(SB) + MOVD $1819, R12 + B callbackasm1(SB) + MOVD $1820, R12 + B callbackasm1(SB) + MOVD $1821, R12 + B callbackasm1(SB) + MOVD $1822, R12 + B callbackasm1(SB) + MOVD $1823, R12 + B callbackasm1(SB) + MOVD $1824, R12 + B callbackasm1(SB) + MOVD $1825, R12 + B callbackasm1(SB) + MOVD $1826, R12 + B callbackasm1(SB) + MOVD $1827, R12 + B callbackasm1(SB) + MOVD $1828, R12 + B callbackasm1(SB) + MOVD $1829, R12 + B callbackasm1(SB) + MOVD $1830, R12 + B callbackasm1(SB) + MOVD $1831, R12 + B callbackasm1(SB) + MOVD $1832, R12 + B callbackasm1(SB) + MOVD $1833, R12 + B callbackasm1(SB) + MOVD $1834, R12 + B callbackasm1(SB) + MOVD $1835, R12 + B callbackasm1(SB) + MOVD $1836, R12 + B callbackasm1(SB) + MOVD $1837, R12 + B callbackasm1(SB) + MOVD $1838, R12 + B callbackasm1(SB) + MOVD $1839, R12 + B callbackasm1(SB) + MOVD $1840, R12 + B callbackasm1(SB) + MOVD $1841, R12 + B callbackasm1(SB) + MOVD $1842, R12 + B callbackasm1(SB) + MOVD $1843, R12 + B callbackasm1(SB) + MOVD $1844, R12 + B callbackasm1(SB) + MOVD $1845, R12 + B callbackasm1(SB) + MOVD $1846, R12 + B callbackasm1(SB) + MOVD $1847, R12 + B callbackasm1(SB) + MOVD $1848, R12 + B callbackasm1(SB) + MOVD $1849, R12 + B callbackasm1(SB) + MOVD $1850, R12 + B callbackasm1(SB) + MOVD $1851, R12 + B callbackasm1(SB) + MOVD $1852, R12 + B callbackasm1(SB) + MOVD $1853, R12 + B callbackasm1(SB) + MOVD $1854, R12 + B callbackasm1(SB) + MOVD $1855, R12 + B callbackasm1(SB) + MOVD $1856, R12 + B callbackasm1(SB) + MOVD $1857, R12 + B callbackasm1(SB) + MOVD $1858, R12 + B callbackasm1(SB) + MOVD $1859, R12 + B callbackasm1(SB) + MOVD $1860, R12 + B callbackasm1(SB) + MOVD $1861, R12 + B callbackasm1(SB) + MOVD $1862, R12 + B callbackasm1(SB) + MOVD $1863, R12 + B callbackasm1(SB) + MOVD $1864, R12 + B callbackasm1(SB) + MOVD $1865, R12 + B callbackasm1(SB) + MOVD $1866, R12 + B callbackasm1(SB) + MOVD $1867, R12 + B callbackasm1(SB) + MOVD $1868, R12 + B callbackasm1(SB) + MOVD $1869, R12 + B callbackasm1(SB) + MOVD $1870, R12 + B callbackasm1(SB) + MOVD $1871, R12 + B callbackasm1(SB) + MOVD $1872, R12 + B callbackasm1(SB) + MOVD $1873, R12 + B callbackasm1(SB) + MOVD $1874, R12 + B callbackasm1(SB) + MOVD $1875, R12 + B callbackasm1(SB) + MOVD $1876, R12 + B callbackasm1(SB) + MOVD $1877, R12 + B callbackasm1(SB) + MOVD $1878, R12 + B callbackasm1(SB) + MOVD $1879, R12 + B callbackasm1(SB) + MOVD $1880, R12 + B callbackasm1(SB) + MOVD $1881, R12 + B callbackasm1(SB) + MOVD $1882, R12 + B callbackasm1(SB) + MOVD $1883, R12 + B callbackasm1(SB) + MOVD $1884, R12 + B callbackasm1(SB) + MOVD $1885, R12 + B callbackasm1(SB) + MOVD $1886, R12 + B callbackasm1(SB) + MOVD $1887, R12 + B callbackasm1(SB) + MOVD $1888, R12 + B callbackasm1(SB) + MOVD $1889, R12 + B callbackasm1(SB) + MOVD $1890, R12 + B callbackasm1(SB) + MOVD $1891, R12 + B callbackasm1(SB) + MOVD $1892, R12 + B callbackasm1(SB) + MOVD $1893, R12 + B callbackasm1(SB) + MOVD $1894, R12 + B callbackasm1(SB) + MOVD $1895, R12 + B callbackasm1(SB) + MOVD $1896, R12 + B callbackasm1(SB) + MOVD $1897, R12 + B callbackasm1(SB) + MOVD $1898, R12 + B callbackasm1(SB) + MOVD $1899, R12 + B callbackasm1(SB) + MOVD $1900, R12 + B callbackasm1(SB) + MOVD $1901, R12 + B callbackasm1(SB) + MOVD $1902, R12 + B callbackasm1(SB) + MOVD $1903, R12 + B callbackasm1(SB) + MOVD $1904, R12 + B callbackasm1(SB) + MOVD $1905, R12 + B callbackasm1(SB) + MOVD $1906, R12 + B callbackasm1(SB) + MOVD $1907, R12 + B callbackasm1(SB) + MOVD $1908, R12 + B callbackasm1(SB) + MOVD $1909, R12 + B callbackasm1(SB) + MOVD $1910, R12 + B callbackasm1(SB) + MOVD $1911, R12 + B callbackasm1(SB) + MOVD $1912, R12 + B callbackasm1(SB) + MOVD $1913, R12 + B callbackasm1(SB) + MOVD $1914, R12 + B callbackasm1(SB) + MOVD $1915, R12 + B callbackasm1(SB) + MOVD $1916, R12 + B callbackasm1(SB) + MOVD $1917, R12 + B callbackasm1(SB) + MOVD $1918, R12 + B callbackasm1(SB) + MOVD $1919, R12 + B callbackasm1(SB) + MOVD $1920, R12 + B callbackasm1(SB) + MOVD $1921, R12 + B callbackasm1(SB) + MOVD $1922, R12 + B callbackasm1(SB) + MOVD $1923, R12 + B callbackasm1(SB) + MOVD $1924, R12 + B callbackasm1(SB) + MOVD $1925, R12 + B callbackasm1(SB) + MOVD $1926, R12 + B callbackasm1(SB) + MOVD $1927, R12 + B callbackasm1(SB) + MOVD $1928, R12 + B callbackasm1(SB) + MOVD $1929, R12 + B callbackasm1(SB) + MOVD $1930, R12 + B callbackasm1(SB) + MOVD $1931, R12 + B callbackasm1(SB) + MOVD $1932, R12 + B callbackasm1(SB) + MOVD $1933, R12 + B callbackasm1(SB) + MOVD $1934, R12 + B callbackasm1(SB) + MOVD $1935, R12 + B callbackasm1(SB) + MOVD $1936, R12 + B callbackasm1(SB) + MOVD $1937, R12 + B callbackasm1(SB) + MOVD $1938, R12 + B callbackasm1(SB) + MOVD $1939, R12 + B callbackasm1(SB) + MOVD $1940, R12 + B callbackasm1(SB) + MOVD $1941, R12 + B callbackasm1(SB) + MOVD $1942, R12 + B callbackasm1(SB) + MOVD $1943, R12 + B callbackasm1(SB) + MOVD $1944, R12 + B callbackasm1(SB) + MOVD $1945, R12 + B callbackasm1(SB) + MOVD $1946, R12 + B callbackasm1(SB) + MOVD $1947, R12 + B callbackasm1(SB) + MOVD $1948, R12 + B callbackasm1(SB) + MOVD $1949, R12 + B callbackasm1(SB) + MOVD $1950, R12 + B callbackasm1(SB) + MOVD $1951, R12 + B callbackasm1(SB) + MOVD $1952, R12 + B callbackasm1(SB) + MOVD $1953, R12 + B callbackasm1(SB) + MOVD $1954, R12 + B callbackasm1(SB) + MOVD $1955, R12 + B callbackasm1(SB) + MOVD $1956, R12 + B callbackasm1(SB) + MOVD $1957, R12 + B callbackasm1(SB) + MOVD $1958, R12 + B callbackasm1(SB) + MOVD $1959, R12 + B callbackasm1(SB) + MOVD $1960, R12 + B callbackasm1(SB) + MOVD $1961, R12 + B callbackasm1(SB) + MOVD $1962, R12 + B callbackasm1(SB) + MOVD $1963, R12 + B callbackasm1(SB) + MOVD $1964, R12 + B callbackasm1(SB) + MOVD $1965, R12 + B callbackasm1(SB) + MOVD $1966, R12 + B callbackasm1(SB) + MOVD $1967, R12 + B callbackasm1(SB) + MOVD $1968, R12 + B callbackasm1(SB) + MOVD $1969, R12 + B callbackasm1(SB) + MOVD $1970, R12 + B callbackasm1(SB) + MOVD $1971, R12 + B callbackasm1(SB) + MOVD $1972, R12 + B callbackasm1(SB) + MOVD $1973, R12 + B callbackasm1(SB) + MOVD $1974, R12 + B callbackasm1(SB) + MOVD $1975, R12 + B callbackasm1(SB) + MOVD $1976, R12 + B callbackasm1(SB) + MOVD $1977, R12 + B callbackasm1(SB) + MOVD $1978, R12 + B callbackasm1(SB) + MOVD $1979, R12 + B callbackasm1(SB) + MOVD $1980, R12 + B callbackasm1(SB) + MOVD $1981, R12 + B callbackasm1(SB) + MOVD $1982, R12 + B callbackasm1(SB) + MOVD $1983, R12 + B callbackasm1(SB) + MOVD $1984, R12 + B callbackasm1(SB) + MOVD $1985, R12 + B callbackasm1(SB) + MOVD $1986, R12 + B callbackasm1(SB) + MOVD $1987, R12 + B callbackasm1(SB) + MOVD $1988, R12 + B callbackasm1(SB) + MOVD $1989, R12 + B callbackasm1(SB) + MOVD $1990, R12 + B callbackasm1(SB) + MOVD $1991, R12 + B callbackasm1(SB) + MOVD $1992, R12 + B callbackasm1(SB) + MOVD $1993, R12 + B callbackasm1(SB) + MOVD $1994, R12 + B callbackasm1(SB) + MOVD $1995, R12 + B callbackasm1(SB) + MOVD $1996, R12 + B callbackasm1(SB) + MOVD $1997, R12 + B callbackasm1(SB) + MOVD $1998, R12 + B callbackasm1(SB) + MOVD $1999, R12 + B callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_loong64.s b/vendor/github.com/ebitengine/purego/zcallback_loong64.s index e20c598a..c5dcd48e 100644 --- a/vendor/github.com/ebitengine/purego/zcallback_loong64.s +++ b/vendor/github.com/ebitengine/purego/zcallback_loong64.s @@ -11,4004 +11,4004 @@ // 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) +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 00000000..702243b1 --- /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 00000000..f341a87e --- /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 00000000..6b5e2b03 --- /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/goccy/go-json/.codecov.yml b/vendor/github.com/goccy/go-json/.codecov.yml new file mode 100644 index 00000000..e9813457 --- /dev/null +++ b/vendor/github.com/goccy/go-json/.codecov.yml @@ -0,0 +1,32 @@ +codecov: + require_ci_to_pass: yes + +coverage: + precision: 2 + round: down + range: "70...100" + + status: + project: + default: + target: 70% + threshold: 2% + patch: off + changes: no + +parsers: + gcov: + branch_detection: + conditional: yes + loop: yes + method: no + macro: no + +comment: + layout: "header,diff" + behavior: default + require_changes: no + +ignore: + - internal/encoder/vm_color + - internal/encoder/vm_color_indent diff --git a/vendor/github.com/goccy/go-json/.gitignore b/vendor/github.com/goccy/go-json/.gitignore new file mode 100644 index 00000000..37828382 --- /dev/null +++ b/vendor/github.com/goccy/go-json/.gitignore @@ -0,0 +1,2 @@ +cover.html +cover.out diff --git a/vendor/github.com/goccy/go-json/.golangci.yml b/vendor/github.com/goccy/go-json/.golangci.yml new file mode 100644 index 00000000..977accaa --- /dev/null +++ b/vendor/github.com/goccy/go-json/.golangci.yml @@ -0,0 +1,86 @@ +run: + skip-files: + - encode_optype.go + - ".*_test\\.go$" + +linters-settings: + govet: + enable-all: true + disable: + - shadow + +linters: + enable-all: true + disable: + - dogsled + - dupl + - exhaustive + - exhaustivestruct + - errorlint + - forbidigo + - funlen + - gci + - gochecknoglobals + - gochecknoinits + - gocognit + - gocritic + - gocyclo + - godot + - godox + - goerr113 + - gofumpt + - gomnd + - gosec + - ifshort + - lll + - makezero + - nakedret + - nestif + - nlreturn + - paralleltest + - testpackage + - thelper + - wrapcheck + - interfacer + - lll + - nakedret + - nestif + - nlreturn + - testpackage + - wsl + - varnamelen + - nilnil + - ireturn + - govet + - forcetypeassert + - cyclop + - containedctx + - revive + - nosnakecase + - exhaustruct + - depguard + +issues: + exclude-rules: + # not needed + - path: /*.go + text: "ST1003: should not use underscores in package names" + linters: + - stylecheck + - path: /*.go + text: "don't use an underscore in package name" + linters: + - golint + - path: rtype.go + linters: + - golint + - stylecheck + - path: error.go + linters: + - staticcheck + + # Maximum issues count per one linter. Set to 0 to disable. Default is 50. + max-issues-per-linter: 0 + + # Maximum count of issues with the same text. Set to 0 to disable. Default is 3. + max-same-issues: 0 diff --git a/vendor/github.com/goccy/go-json/CHANGELOG.md b/vendor/github.com/goccy/go-json/CHANGELOG.md new file mode 100644 index 00000000..d09bb89c --- /dev/null +++ b/vendor/github.com/goccy/go-json/CHANGELOG.md @@ -0,0 +1,425 @@ +# v0.10.2 - 2023/03/20 + +### New features + +* Support DebugDOT option for debugging encoder ( #440 ) + +### Fix bugs + +* Fix combination of embedding structure and omitempty option ( #442 ) + +# v0.10.1 - 2023/03/13 + +### Fix bugs + +* Fix checkptr error for array decoder ( #415 ) +* Fix added buffer size check when decoding key ( #430 ) +* Fix handling of anonymous fields other than struct ( #431 ) +* Fix to not optimize when lower conversion can't handle byte-by-byte ( #432 ) +* Fix a problem that MarshalIndent does not work when UnorderedMap is specified ( #435 ) +* Fix mapDecoder.DecodeStream() for empty objects containing whitespace ( #425 ) +* Fix an issue that could not set the correct NextField for fields in the embedded structure ( #438 ) + +# v0.10.0 - 2022/11/29 + +### New features + +* Support JSON Path ( #250 ) + +### Fix bugs + +* Fix marshaler for map's key ( #409 ) + +# v0.9.11 - 2022/08/18 + +### Fix bugs + +* Fix unexpected behavior when buffer ends with backslash ( #383 ) +* Fix stream decoding of escaped character ( #387 ) + +# v0.9.10 - 2022/07/15 + +### Fix bugs + +* Fix boundary exception of type caching ( #382 ) + +# v0.9.9 - 2022/07/15 + +### Fix bugs + +* Fix encoding of directed interface with typed nil ( #377 ) +* Fix embedded primitive type encoding using alias ( #378 ) +* Fix slice/array type encoding with types implementing MarshalJSON ( #379 ) +* Fix unicode decoding when the expected buffer state is not met after reading ( #380 ) + +# v0.9.8 - 2022/06/30 + +### Fix bugs + +* Fix decoding of surrogate-pair ( #365 ) +* Fix handling of embedded primitive type ( #366 ) +* Add validation of escape sequence for decoder ( #367 ) +* Fix stream tokenizing respecting UseNumber ( #369 ) +* Fix encoding when struct pointer type that implements Marshal JSON is embedded ( #375 ) + +### Improve performance + +* Improve performance of linkRecursiveCode ( #368 ) + +# v0.9.7 - 2022/04/22 + +### Fix bugs + +#### Encoder + +* Add filtering process for encoding on slow path ( #355 ) +* Fix encoding of interface{} with pointer type ( #363 ) + +#### Decoder + +* Fix map key decoder that implements UnmarshalJSON ( #353 ) +* Fix decoding of []uint8 type ( #361 ) + +### New features + +* Add DebugWith option for encoder ( #356 ) + +# v0.9.6 - 2022/03/22 + +### Fix bugs + +* Correct the handling of the minimum value of int type for decoder ( #344 ) +* Fix bugs of stream decoder's bufferSize ( #349 ) +* Add a guard to use typeptr more safely ( #351 ) + +### Improve decoder performance + +* Improve escapeString's performance ( #345 ) + +### Others + +* Update go version for CI ( #347 ) + +# v0.9.5 - 2022/03/04 + +### Fix bugs + +* Fix panic when decoding time.Time with context ( #328 ) +* Fix reading the next character in buffer to nul consideration ( #338 ) +* Fix incorrect handling on skipValue ( #341 ) + +### Improve decoder performance + +* Improve performance when a payload contains escape sequence ( #334 ) + +# v0.9.4 - 2022/01/21 + +* Fix IsNilForMarshaler for string type with omitempty ( #323 ) +* Fix the case where the embedded field is at the end ( #326 ) + +# v0.9.3 - 2022/01/14 + +* Fix logic of removing struct field for decoder ( #322 ) + +# v0.9.2 - 2022/01/14 + +* Add invalid decoder to delay type error judgment at decode ( #321 ) + +# v0.9.1 - 2022/01/11 + +* Fix encoding of MarshalText/MarshalJSON operation with head offset ( #319 ) + +# v0.9.0 - 2022/01/05 + +### New feature + +* Supports dynamic filtering of struct fields ( #314 ) + +### Improve encoding performance + +* Improve map encoding performance ( #310 ) +* Optimize encoding path for escaped string ( #311 ) +* Add encoding option for performance ( #312 ) + +### Fix bugs + +* Fix panic at encoding map value on 1.18 ( #310 ) +* Fix MarshalIndent for interface type ( #317 ) + +# v0.8.1 - 2021/12/05 + +* Fix operation conversion from PtrHead to Head in Recursive type ( #305 ) + +# v0.8.0 - 2021/12/02 + +* Fix embedded field conflict behavior ( #300 ) +* Refactor compiler for encoder ( #301 #302 ) + +# v0.7.10 - 2021/10/16 + +* Fix conversion from pointer to uint64 ( #294 ) + +# v0.7.9 - 2021/09/28 + +* Fix encoding of nil value about interface type that has method ( #291 ) + +# v0.7.8 - 2021/09/01 + +* Fix mapassign_faststr for indirect struct type ( #283 ) +* Fix encoding of not empty interface type ( #284 ) +* Fix encoding of empty struct interface type ( #286 ) + +# v0.7.7 - 2021/08/25 + +* Fix invalid utf8 on stream decoder ( #279 ) +* Fix buffer length bug on string stream decoder ( #280 ) + +Thank you @orisano !! + +# v0.7.6 - 2021/08/13 + +* Fix nil slice assignment ( #276 ) +* Improve error message ( #277 ) + +# v0.7.5 - 2021/08/12 + +* Fix encoding of embedded struct with tags ( #265 ) +* Fix encoding of embedded struct that isn't first field ( #272 ) +* Fix decoding of binary type with escaped char ( #273 ) + +# v0.7.4 - 2021/07/06 + +* Fix encoding of indirect layout structure ( #264 ) + +# v0.7.3 - 2021/06/29 + +* Fix encoding of pointer type in empty interface ( #262 ) + +# v0.7.2 - 2021/06/26 + +### Fix decoder + +* Add decoder for func type to fix decoding of nil function value ( #257 ) +* Fix stream decoding of []byte type ( #258 ) + +### Performance + +* Improve decoding performance of map[string]interface{} type ( use `mapassign_faststr` ) ( #256 ) +* Improve encoding performance of empty interface type ( remove recursive calling of `vm.Run` ) ( #259 ) + +### Benchmark + +* Add bytedance/sonic as benchmark target ( #254 ) + +# v0.7.1 - 2021/06/18 + +### Fix decoder + +* Fix error when unmarshal empty array ( #253 ) + +# v0.7.0 - 2021/06/12 + +### Support context for MarshalJSON and UnmarshalJSON ( #248 ) + +* json.MarshalContext(context.Context, interface{}, ...json.EncodeOption) ([]byte, error) +* json.NewEncoder(io.Writer).EncodeContext(context.Context, interface{}, ...json.EncodeOption) error +* json.UnmarshalContext(context.Context, []byte, interface{}, ...json.DecodeOption) error +* json.NewDecoder(io.Reader).DecodeContext(context.Context, interface{}) error + +```go +type MarshalerContext interface { + MarshalJSON(context.Context) ([]byte, error) +} + +type UnmarshalerContext interface { + UnmarshalJSON(context.Context, []byte) error +} +``` + +### Add DecodeFieldPriorityFirstWin option ( #242 ) + +In the default behavior, go-json, like encoding/json, will reflect the result of the last evaluation when a field with the same name exists. I've added new options to allow you to change this behavior. `json.DecodeFieldPriorityFirstWin` option reflects the result of the first evaluation if a field with the same name exists. This behavior has a performance advantage as it allows the subsequent strings to be skipped if all fields have been evaluated. + +### Fix encoder + +* Fix indent number contains recursive type ( #249 ) +* Fix encoding of using empty interface as map key ( #244 ) + +### Fix decoder + +* Fix decoding fields containing escaped characters ( #237 ) + +### Refactor + +* Move some tests to subdirectory ( #243 ) +* Refactor package layout for decoder ( #238 ) + +# v0.6.1 - 2021/06/02 + +### Fix encoder + +* Fix value of totalLength for encoding ( #236 ) + +# v0.6.0 - 2021/06/01 + +### Support Colorize option for encoding (#233) + +```go +b, err := json.MarshalWithOption(v, json.Colorize(json.DefaultColorScheme)) +if err != nil { + ... +} +fmt.Println(string(b)) // print colored json +``` + +### Refactor + +* Fix opcode layout - Adjust memory layout of the opcode to 128 bytes in a 64-bit environment ( #230 ) +* Refactor encode option ( #231 ) +* Refactor escape string ( #232 ) + +# v0.5.1 - 2021/5/20 + +### Optimization + +* Add type addrShift to enable bigger encoder/decoder cache ( #213 ) + +### Fix decoder + +* Keep original reference of slice element ( #229 ) + +### Refactor + +* Refactor Debug mode for encoding ( #226 ) +* Generate VM sources for encoding ( #227 ) +* Refactor validator for null/true/false for decoding ( #221 ) + +# v0.5.0 - 2021/5/9 + +### Supports using omitempty and string tags at the same time ( #216 ) + +### Fix decoder + +* Fix stream decoder for unicode char ( #215 ) +* Fix decoding of slice element ( #219 ) +* Fix calculating of buffer length for stream decoder ( #220 ) + +### Refactor + +* replace skipWhiteSpace goto by loop ( #212 ) + +# v0.4.14 - 2021/5/4 + +### Benchmark + +* Add valyala/fastjson to benchmark ( #193 ) +* Add benchmark task for CI ( #211 ) + +### Fix decoder + +* Fix decoding of slice with unmarshal json type ( #198 ) +* Fix decoding of null value for interface type that does not implement Unmarshaler ( #205 ) +* Fix decoding of null value to []byte by json.Unmarshal ( #206 ) +* Fix decoding of backslash char at the end of string ( #207 ) +* Fix stream decoder for null/true/false value ( #208 ) +* Fix stream decoder for slow reader ( #211 ) + +### Performance + +* If cap of slice is enough, reuse slice data for compatibility with encoding/json ( #200 ) + +# v0.4.13 - 2021/4/20 + +### Fix json.Compact and json.Indent + +* Support validation the input buffer for json.Compact and json.Indent ( #189 ) +* Optimize json.Compact and json.Indent ( improve memory footprint ) ( #190 ) + +# v0.4.12 - 2021/4/15 + +### Fix encoder + +* Fix unnecessary indent for empty slice type ( #181 ) +* Fix encoding of omitempty feature for the slice or interface type ( #183 ) +* Fix encoding custom types zero values with omitempty when marshaller exists ( #187 ) + +### Fix decoder + +* Fix decoder for invalid top level value ( #184 ) +* Fix decoder for invalid number value ( #185 ) + +# v0.4.11 - 2021/4/3 + +* Improve decoder performance for interface type + +# v0.4.10 - 2021/4/2 + +### Fix encoder + +* Fixed a bug when encoding slice and map containing recursive structures +* Fixed a logic to determine if indirect reference + +# v0.4.9 - 2021/3/29 + +### Add debug mode + +If you use `json.MarshalWithOption(v, json.Debug())` and `panic` occurred in `go-json`, produces debug information to console. + +### Support a new feature to compatible with encoding/json + +- invalid UTF-8 is coerced to valid UTF-8 ( without performance down ) + +### Fix encoder + +- Fixed handling of MarshalJSON of function type + +### Fix decoding of slice of pointer type + +If there is a pointer value, go-json will use it. (This behavior is necessary to achieve the ability to prioritize pre-filled values). However, since slices are reused internally, there was a bug that referred to the previous pointer value. Therefore, it is not necessary to refer to the pointer value in advance for the slice element, so we explicitly initialize slice element by `nil`. + +# v0.4.8 - 2021/3/21 + +### Reduce memory usage at compile time + +* go-json have used about 2GB of memory at compile time, but now it can compile with about less than 550MB. + +### Fix any encoder's bug + +* Add many test cases for encoder +* Fix composite type ( slice/array/map ) +* Fix pointer types +* Fix encoding of MarshalJSON or MarshalText or json.Number type + +### Refactor encoder + +* Change package layout for reducing memory usage at compile +* Remove anonymous and only operation +* Remove root property from encodeCompileContext and opcode + +### Fix CI + +* Add Go 1.16 +* Remove Go 1.13 +* Fix `make cover` task + +### Number/Delim/Token/RawMessage use the types defined in encoding/json by type alias + +# v0.4.7 - 2021/02/22 + +### Fix decoder + +* Fix decoding of deep recursive structure +* Fix decoding of embedded unexported pointer field +* Fix invalid test case +* Fix decoding of invalid value +* Fix decoding of prefilled value +* Fix not being able to return UnmarshalTypeError when it should be returned +* Fix decoding of null value +* Fix decoding of type of null string +* Use pre allocated pointer if exists it at decoding + +### Reduce memory usage at compile + +* Integrate int/int8/int16/int32/int64 and uint/uint8/uint16/uint32/uint64 operation to reduce memory usage at compile + +### Remove unnecessary optype diff --git a/vendor/github.com/rivo/uniseg/LICENSE.txt b/vendor/github.com/goccy/go-json/LICENSE similarity index 96% rename from vendor/github.com/rivo/uniseg/LICENSE.txt rename to vendor/github.com/goccy/go-json/LICENSE index 5040f1ef..6449c8bf 100644 --- a/vendor/github.com/rivo/uniseg/LICENSE.txt +++ b/vendor/github.com/goccy/go-json/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2019 Oliver Kuederle +Copyright (c) 2020 Masaaki Goshima Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/vendor/github.com/goccy/go-json/Makefile b/vendor/github.com/goccy/go-json/Makefile new file mode 100644 index 00000000..c030577d --- /dev/null +++ b/vendor/github.com/goccy/go-json/Makefile @@ -0,0 +1,39 @@ +PKG := github.com/goccy/go-json + +BIN_DIR := $(CURDIR)/bin +PKGS := $(shell go list ./... | grep -v internal/cmd|grep -v test) +COVER_PKGS := $(foreach pkg,$(PKGS),$(subst $(PKG),.,$(pkg))) + +COMMA := , +EMPTY := +SPACE := $(EMPTY) $(EMPTY) +COVERPKG_OPT := $(subst $(SPACE),$(COMMA),$(COVER_PKGS)) + +$(BIN_DIR): + @mkdir -p $(BIN_DIR) + +.PHONY: cover +cover: + go test -coverpkg=$(COVERPKG_OPT) -coverprofile=cover.out ./... + +.PHONY: cover-html +cover-html: cover + go tool cover -html=cover.out + +.PHONY: lint +lint: golangci-lint + $(BIN_DIR)/golangci-lint run + +golangci-lint: | $(BIN_DIR) + @{ \ + set -e; \ + GOLANGCI_LINT_TMP_DIR=$$(mktemp -d); \ + cd $$GOLANGCI_LINT_TMP_DIR; \ + go mod init tmp; \ + GOBIN=$(BIN_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2; \ + rm -rf $$GOLANGCI_LINT_TMP_DIR; \ + } + +.PHONY: generate +generate: + go generate ./internal/... diff --git a/vendor/github.com/goccy/go-json/README.md b/vendor/github.com/goccy/go-json/README.md new file mode 100644 index 00000000..7bacc54f --- /dev/null +++ b/vendor/github.com/goccy/go-json/README.md @@ -0,0 +1,529 @@ +# go-json + +![Go](https://github.com/goccy/go-json/workflows/Go/badge.svg) +[![GoDoc](https://godoc.org/github.com/goccy/go-json?status.svg)](https://pkg.go.dev/github.com/goccy/go-json?tab=doc) +[![codecov](https://codecov.io/gh/goccy/go-json/branch/master/graph/badge.svg)](https://codecov.io/gh/goccy/go-json) + +Fast JSON encoder/decoder compatible with encoding/json for Go + + + +# Roadmap + +``` +* version ( expected release date ) + +* v0.9.0 + | + | while maintaining compatibility with encoding/json, we will add convenient APIs + | + v +* v1.0.0 +``` + +We are accepting requests for features that will be implemented between v0.9.0 and v.1.0.0. +If you have the API you need, please submit your issue [here](https://github.com/goccy/go-json/issues). + +# Features + +- Drop-in replacement of `encoding/json` +- Fast ( See [Benchmark section](https://github.com/goccy/go-json#benchmarks) ) +- Flexible customization with options +- Coloring the encoded string +- Can propagate context.Context to `MarshalJSON` or `UnmarshalJSON` +- Can dynamically filter the fields of the structure type-safely + +# Installation + +``` +go get github.com/goccy/go-json +``` + +# How to use + +Replace import statement from `encoding/json` to `github.com/goccy/go-json` + +``` +-import "encoding/json" ++import "github.com/goccy/go-json" +``` + +# JSON library comparison + +| name | encoder | decoder | compatible with `encoding/json` | +| :----: | :------: | :-----: | :-----------------------------: | +| encoding/json | yes | yes | N/A | +| [json-iterator/go](https://github.com/json-iterator/go) | yes | yes | partial | +| [easyjson](https://github.com/mailru/easyjson) | yes | yes | no | +| [gojay](https://github.com/francoispqt/gojay) | yes | yes | no | +| [segmentio/encoding/json](https://github.com/segmentio/encoding/tree/master/json) | yes | yes | partial | +| [jettison](https://github.com/wI2L/jettison) | yes | no | no | +| [simdjson-go](https://github.com/minio/simdjson-go) | no | yes | no | +| goccy/go-json | yes | yes | yes | + +- `json-iterator/go` isn't compatible with `encoding/json` in many ways (e.g. https://github.com/json-iterator/go/issues/229 ), but it hasn't been supported for a long time. +- `segmentio/encoding/json` is well supported for encoders, but some are not supported for decoder APIs such as `Token` ( streaming decode ) + +## Other libraries + +- [jingo](https://github.com/bet365/jingo) + +I tried the benchmark but it didn't work. +Also, it seems to panic when it receives an unexpected value because there is no error handling... + +- [ffjson](https://github.com/pquerna/ffjson) + +Benchmarking gave very slow results. +It seems that it is assumed that the user will use the buffer pool properly. +Also, development seems to have already stopped + +# Benchmarks + +``` +$ cd benchmarks +$ go test -bench . +``` + +## Encode + + + + +## Decode + + + + + + +# Fuzzing + +[go-json-fuzz](https://github.com/goccy/go-json-fuzz) is the repository for fuzzing tests. +If you run the test in this repository and find a bug, please commit to corpus to go-json-fuzz and report the issue to [go-json](https://github.com/goccy/go-json/issues). + +# How it works + +`go-json` is very fast in both encoding and decoding compared to other libraries. +It's easier to implement by using automatic code generation for performance or by using a dedicated interface, but `go-json` dares to stick to compatibility with `encoding/json` and is the simple interface. Despite this, we are developing with the aim of being the fastest library. + +Here, we explain the various speed-up techniques implemented by `go-json`. + +## Basic technique + +The techniques listed here are the ones used by most of the libraries listed above. + +### Buffer reuse + +Since the only value required for the result of `json.Marshal(interface{}) ([]byte, error)` is `[]byte`, the only value that must be allocated during encoding is the return value `[]byte` . + +Also, as the number of allocations increases, the performance will be affected, so the number of allocations should be kept as low as possible when creating `[]byte`. + +Therefore, there is a technique to reduce the number of times a new buffer must be allocated by reusing the buffer used for the previous encoding by using `sync.Pool`. + +Finally, you allocate a buffer that is as long as the resulting buffer and copy the contents into it, you only need to allocate the buffer once in theory. + +```go +type buffer struct { + data []byte +} + +var bufPool = sync.Pool{ + New: func() interface{} { + return &buffer{data: make([]byte, 0, 1024)} + }, +} + +buf := bufPool.Get().(*buffer) +data := encode(buf.data) // reuse buf.data + +newBuf := make([]byte, len(data)) +copy(newBuf, buf) + +buf.data = data +bufPool.Put(buf) +``` + +### Elimination of reflection + +As you know, the reflection operation is very slow. + +Therefore, using the fact that the address position where the type information is stored is fixed for each binary ( we call this `typeptr` ), +we can use the address in the type information to call a pre-built optimized process. + +For example, you can get the address to the type information from `interface{}` as follows and you can use that information to call a process that does not have reflection. + +To process without reflection, pass a pointer (`unsafe.Pointer`) to the value is stored. + +```go + +type emptyInterface struct { + typ unsafe.Pointer + ptr unsafe.Pointer +} + +var typeToEncoder = map[uintptr]func(unsafe.Pointer)([]byte, error){} + +func Marshal(v interface{}) ([]byte, error) { + iface := (*emptyInterface)(unsafe.Pointer(&v) + typeptr := uintptr(iface.typ) + if enc, exists := typeToEncoder[typeptr]; exists { + return enc(iface.ptr) + } + ... +} +``` + +※ In reality, `typeToEncoder` can be referenced by multiple goroutines, so exclusive control is required. + +## Unique speed-up technique + +## Encoder + +### Do not escape arguments of `Marshal` + +`json.Marshal` and `json.Unmarshal` receive `interface{}` value and they perform type determination dynamically to process. +In normal case, you need to use the `reflect` library to determine the type dynamically, but since `reflect.Type` is defined as `interface`, when you call the method of `reflect.Type`, The reflect's argument is escaped. + +Therefore, the arguments for `Marshal` and `Unmarshal` are always escaped to the heap. +However, `go-json` can use the feature of `reflect.Type` while avoiding escaping. + +`reflect.Type` is defined as `interface`, but in reality `reflect.Type` is implemented only by the structure `rtype` defined in the `reflect` package. +For this reason, to date `reflect.Type` is the same as `*reflect.rtype`. + +Therefore, by directly handling `*reflect.rtype`, which is an implementation of `reflect.Type`, it is possible to avoid escaping because it changes from `interface` to using `struct`. + +The technique for working with `*reflect.rtype` directly from `go-json` is implemented at [rtype.go](https://github.com/goccy/go-json/blob/master/internal/runtime/rtype.go) + +Also, the same technique is cut out as a library ( https://github.com/goccy/go-reflect ) + +Initially this feature was the default behavior of `go-json`. +But after careful testing, I found that I passed a large value to `json.Marshal()` and if the argument could not be assigned to the stack, it could not be properly escaped to the heap (a bug in the Go compiler). + +Therefore, this feature will be provided as an **optional** until this issue is resolved. + +To use it, add `NoEscape` like `MarshalNoEscape()` + +### Encoding using opcode sequence + +I explained that you can use `typeptr` to call a pre-built process from type information. + +In other libraries, this dedicated process is processed by making it an function calling like anonymous function, but function calls are inherently slow processes and should be avoided as much as possible. + +Therefore, `go-json` adopted the Instruction-based execution processing system, which is also used to implement virtual machines for programming language. + +If it is the first type to encode, create the opcode ( instruction ) sequence required for encoding. +From the second time onward, use `typeptr` to get the cached pre-built opcode sequence and encode it based on it. An example of the opcode sequence is shown below. + +```go +json.Marshal(struct{ + X int `json:"x"` + Y string `json:"y"` +}{X: 1, Y: "hello"}) +``` + +When encoding a structure like the one above, create a sequence of opcodes like this: + +``` +- opStructFieldHead ( `{` ) +- opStructFieldInt ( `"x": 1,` ) +- opStructFieldString ( `"y": "hello"` ) +- opStructEnd ( `}` ) +- opEnd +``` + +※ When processing each operation, write the letters on the right. + +In addition, each opcode is managed by the following structure ( +Pseudo code ). + +```go +type opType int +const ( + opStructFieldHead opType = iota + opStructFieldInt + opStructFieldStirng + opStructEnd + opEnd +) +type opcode struct { + op opType + key []byte + next *opcode +} +``` + +The process of encoding using the opcode sequence is roughly implemented as follows. + +```go +func encode(code *opcode, b []byte, p unsafe.Pointer) ([]byte, error) { + for { + switch code.op { + case opStructFieldHead: + b = append(b, '{') + code = code.next + case opStructFieldInt: + b = append(b, code.key...) + b = appendInt((*int)(unsafe.Pointer(uintptr(p)+code.offset))) + code = code.next + case opStructFieldString: + b = append(b, code.key...) + b = appendString((*string)(unsafe.Pointer(uintptr(p)+code.offset))) + code = code.next + case opStructEnd: + b = append(b, '}') + code = code.next + case opEnd: + goto END + } + } +END: + return b, nil +} +``` + +In this way, the huge `switch-case` is used to encode by manipulating the linked list opcodes to avoid unnecessary function calls. + +### Opcode sequence optimization + +One of the advantages of encoding using the opcode sequence is the ease of optimization. +The opcode sequence mentioned above is actually converted into the following optimized operations and used. + +``` +- opStructFieldHeadInt ( `{"x": 1,` ) +- opStructEndString ( `"y": "hello"}` ) +- opEnd +``` + +It has been reduced from 5 opcodes to 3 opcodes ! +Reducing the number of opcodees means reducing the number of branches with `switch-case`. +In other words, the closer the number of operations is to 1, the faster the processing can be performed. + +In `go-json`, optimization to reduce the number of opcodes itself like the above and it speeds up by preparing opcodes with optimized paths. + +### Change recursive call from CALL to JMP + +Recursive processing is required during encoding if the type is defined recursively as follows: + +```go +type T struct { + X int + U *U +} + +type U struct { + T *T +} + +b, err := json.Marshal(&T{ + X: 1, + U: &U{ + T: &T{ + X: 2, + }, + }, +}) +fmt.Println(string(b)) // {"X":1,"U":{"T":{"X":2,"U":null}}} +``` + +In `go-json`, recursive processing is processed by the operation type of ` opStructFieldRecursive`. + +In this operation, after acquiring the opcode sequence used for recursive processing, the function is **not** called recursively as it is, but the necessary values ​​are saved by itself and implemented by moving to the next operation. + +The technique of implementing recursive processing with the `JMP` operation while avoiding the `CALL` operation is a famous technique for implementing a high-speed virtual machine. + +For more details, please refer to [the article](https://engineering.mercari.com/blog/entry/1599563768-081104c850) ( but Japanese only ). + +### Dispatch by typeptr from map to slice + +When retrieving the data cached from the type information by `typeptr`, we usually use map. +Map requires exclusive control, so use `sync.Map` for a naive implementation. + +However, this is slow, so it's a good idea to use the `atomic` package for exclusive control as implemented by `segmentio/encoding/json` ( https://github.com/segmentio/encoding/blob/master/json/codec.go#L41-L55 ). + +This implementation slows down the set instead of speeding up the get, but it works well because of the nature of the library, it encodes much more for the same type. + +However, as a result of profiling, I noticed that `runtime.mapaccess2` accounts for a significant percentage of the execution time. So I thought if I could change the lookup from map to slice. + +There is an API named `typelinks` defined in the `runtime` package that the `reflect` package uses internally. +This allows you to get all the type information defined in the binary at runtime. + +The fact that all type information can be acquired means that by constructing slices in advance with the acquired total number of type information, it is possible to look up with the value of `typeptr` without worrying about out-of-range access. + +However, if there is too much type information, it will use a lot of memory, so by default we will only use this optimization if the slice size fits within **2Mib** . + +If this approach is not available, it will fall back to the `atomic` based process described above. + +If you want to know more, please refer to the implementation [here](https://github.com/goccy/go-json/blob/master/internal/runtime/type.go#L36-L100) + +## Decoder + +### Dispatch by typeptr from map to slice + +Like the encoder, the decoder also uses typeptr to call the dedicated process. + +### Faster termination character inspection using NUL character + +In order to decode, you have to traverse the input buffer character by position. +At that time, if you check whether the buffer has reached the end, it will be very slow. + +`buf` : `[]byte` type variable. holds the string passed to the decoder +`cursor` : `int64` type variable. holds the current read position + +```go +buflen := len(buf) +for ; cursor < buflen; cursor++ { // compare cursor and buflen at all times, it is so slow. + switch buf[cursor] { + case ' ', '\n', '\r', '\t': + } +} +``` + +Therefore, by adding the `NUL` (`\000`) character to the end of the read buffer as shown below, it is possible to check the termination character at the same time as other characters. + +```go +for { + switch buf[cursor] { + case ' ', '\n', '\r', '\t': + case '\000': + return nil + } + cursor++ +} +``` + +### Use Boundary Check Elimination + +Due to the `NUL` character optimization, the Go compiler does a boundary check every time, even though `buf[cursor]` does not cause out-of-range access. + +Therefore, `go-json` eliminates boundary check by fetching characters for hotspot by pointer operation. For example, the following code. + +```go +func char(ptr unsafe.Pointer, offset int64) byte { + return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset))) +} + +p := (*sliceHeader)(&unsafe.Pointer(buf)).data +for { + switch char(p, cursor) { + case ' ', '\n', '\r', '\t': + case '\000': + return nil + } + cursor++ +} +``` + +### Checking the existence of fields of struct using Bitmaps + +I found by the profiling result, in the struct decode, lookup process for field was taking a long time. + +For example, consider decoding a string like `{"a":1,"b":2,"c":3}` into the following structure: + +```go +type T struct { + A int `json:"a"` + B int `json:"b"` + C int `json:"c"` +} +``` + +At this time, it was found that it takes a lot of time to acquire the decoding process corresponding to the field from the field name as shown below during the decoding process. + +```go +fieldName := decodeKey(buf, cursor) // "a" or "b" or "c" +decoder, exists := fieldToDecoderMap[fieldName] // so slow +if exists { + decoder(buf, cursor) +} else { + skipValue(buf, cursor) +} +``` + +To improve this process, `json-iterator/go` is optimized so that it can be branched by switch-case when the number of fields in the structure is 10 or less (switch-case is faster than map). However, there is a risk of hash collision because the value hashed by the FNV algorithm is used for conditional branching. Also, `gojay` processes this part at high speed by letting the library user yourself write `switch-case`. + + +`go-json` considers and implements a new approach that is different from these. I call this **bitmap field optimization**. + +The range of values ​​per character can be represented by `[256]byte`. Also, if the number of fields in the structure is 8 or less, `int8` type can represent the state of each field. +In other words, it has the following structure. + +- Base ( 8bit ): `00000000` +- Key "a": `00000001` ( assign key "a" to the first bit ) +- Key "b": `00000010` ( assign key "b" to the second bit ) +- Key "c": `00000100` ( assign key "c" to the third bit ) + +Bitmap structure is the following + +``` + | key index(0) | +------------------------ + 0 | 00000000 | + 1 | 00000000 | +~~ | | +97 (a) | 00000001 | +98 (b) | 00000010 | +99 (c) | 00000100 | +~~ | | +255 | 00000000 | +``` + +You can think of this as a Bitmap with a height of `256` and a width of the maximum string length in the field name. +In other words, it can be represented by the following type . + +```go +[maxFieldKeyLength][256]int8 +``` + +When decoding a field character, check whether the corresponding character exists by referring to the pre-built bitmap like the following. + +```go +var curBit int8 = math.MaxInt8 // 11111111 + +c := char(buf, cursor) +bit := bitmap[keyIdx][c] +curBit &= bit +if curBit == 0 { + // not found field +} +``` + +If `curBit` is not `0` until the end of the field string, then the string is +You may have hit one of the fields. +But the possibility is that if the decoded string is shorter than the field string, you will get a false hit. + +- input: `{"a":1}` +```go +type T struct { + X int `json:"abc"` +} +``` +※ Since `a` is shorter than `abc`, it can decode to the end of the field character without `curBit` being 0. + +Rest assured. In this case, it doesn't matter because you can tell if you hit by comparing the string length of `a` with the string length of `abc`. + +Finally, calculate the position of the bit where `1` is set and get the corresponding value, and you're done. + +Using this technique, field lookups are possible with only bitwise operations and access to slices. + +`go-json` uses a similar technique for fields with 9 or more and 16 or less fields. At this time, Bitmap is constructed as `[maxKeyLen][256]int16` type. + +Currently, this optimization is not performed when the maximum length of the field name is long (specifically, 64 bytes or more) in addition to the limitation of the number of fields from the viewpoint of saving memory usage. + +### Others + +I have done a lot of other optimizations. I will find time to write about them. If you have any questions about what's written here or other optimizations, please visit the `#go-json` channel on `gophers.slack.com` . + +## Reference + +Regarding the story of go-json, there are the following articles in Japanese only. + +- https://speakerdeck.com/goccy/zui-su-falsejsonraiburariwoqiu-mete +- https://engineering.mercari.com/blog/entry/1599563768-081104c850/ + +# Looking for Sponsors + +I'm looking for sponsors this library. This library is being developed as a personal project in my spare time. If you want a quick response or problem resolution when using this library in your project, please register as a [sponsor](https://github.com/sponsors/goccy). I will cooperate as much as possible. Of course, this library is developed as an MIT license, so you can use it freely for free. + +# License + +MIT diff --git a/vendor/github.com/goccy/go-json/color.go b/vendor/github.com/goccy/go-json/color.go new file mode 100644 index 00000000..e80b22b4 --- /dev/null +++ b/vendor/github.com/goccy/go-json/color.go @@ -0,0 +1,68 @@ +package json + +import ( + "fmt" + + "github.com/goccy/go-json/internal/encoder" +) + +type ( + ColorFormat = encoder.ColorFormat + ColorScheme = encoder.ColorScheme +) + +const escape = "\x1b" + +type colorAttr int + +//nolint:deadcode,varcheck +const ( + fgBlackColor colorAttr = iota + 30 + fgRedColor + fgGreenColor + fgYellowColor + fgBlueColor + fgMagentaColor + fgCyanColor + fgWhiteColor +) + +//nolint:deadcode,varcheck +const ( + fgHiBlackColor colorAttr = iota + 90 + fgHiRedColor + fgHiGreenColor + fgHiYellowColor + fgHiBlueColor + fgHiMagentaColor + fgHiCyanColor + fgHiWhiteColor +) + +func createColorFormat(attr colorAttr) ColorFormat { + return ColorFormat{ + Header: wrapColor(attr), + Footer: resetColor(), + } +} + +func wrapColor(attr colorAttr) string { + return fmt.Sprintf("%s[%dm", escape, attr) +} + +func resetColor() string { + return wrapColor(colorAttr(0)) +} + +var ( + DefaultColorScheme = &ColorScheme{ + Int: createColorFormat(fgHiMagentaColor), + Uint: createColorFormat(fgHiMagentaColor), + Float: createColorFormat(fgHiMagentaColor), + Bool: createColorFormat(fgHiYellowColor), + String: createColorFormat(fgHiGreenColor), + Binary: createColorFormat(fgHiRedColor), + ObjectKey: createColorFormat(fgHiCyanColor), + Null: createColorFormat(fgBlueColor), + } +) diff --git a/vendor/github.com/goccy/go-json/decode.go b/vendor/github.com/goccy/go-json/decode.go new file mode 100644 index 00000000..74c6ac3b --- /dev/null +++ b/vendor/github.com/goccy/go-json/decode.go @@ -0,0 +1,263 @@ +package json + +import ( + "context" + "fmt" + "io" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/decoder" + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type Decoder struct { + s *decoder.Stream +} + +const ( + nul = '\000' +) + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +func unmarshal(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + src := make([]byte, len(data)+1) // append nul byte to the end + copy(src, data) + + header := (*emptyInterface)(unsafe.Pointer(&v)) + + if err := validateType(header.typ, uintptr(header.ptr)); err != nil { + return err + } + dec, err := decoder.CompileToGetDecoder(header.typ) + if err != nil { + return err + } + ctx := decoder.TakeRuntimeContext() + ctx.Buf = src + ctx.Option.Flags = 0 + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + cursor, err := dec.Decode(ctx, 0, 0, header.ptr) + if err != nil { + decoder.ReleaseRuntimeContext(ctx) + return err + } + decoder.ReleaseRuntimeContext(ctx) + return validateEndBuf(src, cursor) +} + +func unmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + src := make([]byte, len(data)+1) // append nul byte to the end + copy(src, data) + + header := (*emptyInterface)(unsafe.Pointer(&v)) + + if err := validateType(header.typ, uintptr(header.ptr)); err != nil { + return err + } + dec, err := decoder.CompileToGetDecoder(header.typ) + if err != nil { + return err + } + rctx := decoder.TakeRuntimeContext() + rctx.Buf = src + rctx.Option.Flags = 0 + rctx.Option.Flags |= decoder.ContextOption + rctx.Option.Context = ctx + for _, optFunc := range optFuncs { + optFunc(rctx.Option) + } + cursor, err := dec.Decode(rctx, 0, 0, header.ptr) + if err != nil { + decoder.ReleaseRuntimeContext(rctx) + return err + } + decoder.ReleaseRuntimeContext(rctx) + return validateEndBuf(src, cursor) +} + +var ( + pathDecoder = decoder.NewPathDecoder() +) + +func extractFromPath(path *Path, data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) { + if path.path.RootSelectorOnly { + return [][]byte{data}, nil + } + src := make([]byte, len(data)+1) // append nul byte to the end + copy(src, data) + + ctx := decoder.TakeRuntimeContext() + ctx.Buf = src + ctx.Option.Flags = 0 + ctx.Option.Flags |= decoder.PathOption + ctx.Option.Path = path.path + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + paths, cursor, err := pathDecoder.DecodePath(ctx, 0, 0) + if err != nil { + decoder.ReleaseRuntimeContext(ctx) + return nil, err + } + decoder.ReleaseRuntimeContext(ctx) + if err := validateEndBuf(src, cursor); err != nil { + return nil, err + } + return paths, nil +} + +func unmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + src := make([]byte, len(data)+1) // append nul byte to the end + copy(src, data) + + header := (*emptyInterface)(unsafe.Pointer(&v)) + + if err := validateType(header.typ, uintptr(header.ptr)); err != nil { + return err + } + dec, err := decoder.CompileToGetDecoder(header.typ) + if err != nil { + return err + } + + ctx := decoder.TakeRuntimeContext() + ctx.Buf = src + ctx.Option.Flags = 0 + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + cursor, err := dec.Decode(ctx, 0, 0, noescape(header.ptr)) + if err != nil { + decoder.ReleaseRuntimeContext(ctx) + return err + } + decoder.ReleaseRuntimeContext(ctx) + return validateEndBuf(src, cursor) +} + +func validateEndBuf(src []byte, cursor int64) error { + for { + switch src[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case nul: + return nil + } + return errors.ErrSyntax( + fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]), + cursor+1, + ) + } +} + +//nolint:staticcheck +//go:nosplit +func noescape(p unsafe.Pointer) unsafe.Pointer { + x := uintptr(p) + return unsafe.Pointer(x ^ 0) +} + +func validateType(typ *runtime.Type, p uintptr) error { + if typ == nil || typ.Kind() != reflect.Ptr || p == 0 { + return &InvalidUnmarshalError{Type: runtime.RType2Type(typ)} + } + return nil +} + +// NewDecoder returns a new decoder that reads from r. +// +// The decoder introduces its own buffering and may +// read data from r beyond the JSON values requested. +func NewDecoder(r io.Reader) *Decoder { + s := decoder.NewStream(r) + return &Decoder{ + s: s, + } +} + +// Buffered returns a reader of the data remaining in the Decoder's +// buffer. The reader is valid until the next call to Decode. +func (d *Decoder) Buffered() io.Reader { + return d.s.Buffered() +} + +// Decode reads the next JSON-encoded value from its +// input and stores it in the value pointed to by v. +// +// See the documentation for Unmarshal for details about +// the conversion of JSON into a Go value. +func (d *Decoder) Decode(v interface{}) error { + return d.DecodeWithOption(v) +} + +// DecodeContext reads the next JSON-encoded value from its +// input and stores it in the value pointed to by v with context.Context. +func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error { + d.s.Option.Flags |= decoder.ContextOption + d.s.Option.Context = ctx + return d.DecodeWithOption(v) +} + +func (d *Decoder) DecodeWithOption(v interface{}, optFuncs ...DecodeOptionFunc) error { + header := (*emptyInterface)(unsafe.Pointer(&v)) + typ := header.typ + ptr := uintptr(header.ptr) + typeptr := uintptr(unsafe.Pointer(typ)) + // noescape trick for header.typ ( reflect.*rtype ) + copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr)) + + if err := validateType(copiedType, ptr); err != nil { + return err + } + + dec, err := decoder.CompileToGetDecoder(typ) + if err != nil { + return err + } + if err := d.s.PrepareForDecode(); err != nil { + return err + } + s := d.s + for _, optFunc := range optFuncs { + optFunc(s.Option) + } + if err := dec.DecodeStream(s, 0, header.ptr); err != nil { + return err + } + s.Reset() + return nil +} + +func (d *Decoder) More() bool { + return d.s.More() +} + +func (d *Decoder) Token() (Token, error) { + return d.s.Token() +} + +// DisallowUnknownFields causes the Decoder to return an error when the destination +// is a struct and the input contains object keys which do not match any +// non-ignored, exported fields in the destination. +func (d *Decoder) DisallowUnknownFields() { + d.s.DisallowUnknownFields = true +} + +func (d *Decoder) InputOffset() int64 { + return d.s.TotalOffset() +} + +// UseNumber causes the Decoder to unmarshal a number into an interface{} as a +// Number instead of as a float64. +func (d *Decoder) UseNumber() { + d.s.UseNumber = true +} diff --git a/vendor/github.com/goccy/go-json/docker-compose.yml b/vendor/github.com/goccy/go-json/docker-compose.yml new file mode 100644 index 00000000..db40c79a --- /dev/null +++ b/vendor/github.com/goccy/go-json/docker-compose.yml @@ -0,0 +1,13 @@ +version: '2' +services: + go-json: + image: golang:1.18 + volumes: + - '.:/go/src/go-json' + deploy: + resources: + limits: + memory: 620M + working_dir: /go/src/go-json + command: | + sh -c "go test -c . && ls go-json.test" diff --git a/vendor/github.com/goccy/go-json/encode.go b/vendor/github.com/goccy/go-json/encode.go new file mode 100644 index 00000000..c5173825 --- /dev/null +++ b/vendor/github.com/goccy/go-json/encode.go @@ -0,0 +1,326 @@ +package json + +import ( + "context" + "io" + "os" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/encoder/vm" + "github.com/goccy/go-json/internal/encoder/vm_color" + "github.com/goccy/go-json/internal/encoder/vm_color_indent" + "github.com/goccy/go-json/internal/encoder/vm_indent" +) + +// An Encoder writes JSON values to an output stream. +type Encoder struct { + w io.Writer + enabledIndent bool + enabledHTMLEscape bool + prefix string + indentStr string +} + +// NewEncoder returns a new encoder that writes to w. +func NewEncoder(w io.Writer) *Encoder { + return &Encoder{w: w, enabledHTMLEscape: true} +} + +// Encode writes the JSON encoding of v to the stream, followed by a newline character. +// +// See the documentation for Marshal for details about the conversion of Go values to JSON. +func (e *Encoder) Encode(v interface{}) error { + return e.EncodeWithOption(v) +} + +// EncodeWithOption call Encode with EncodeOption. +func (e *Encoder) EncodeWithOption(v interface{}, optFuncs ...EncodeOptionFunc) error { + ctx := encoder.TakeRuntimeContext() + ctx.Option.Flag = 0 + + err := e.encodeWithOption(ctx, v, optFuncs...) + + encoder.ReleaseRuntimeContext(ctx) + return err +} + +// EncodeContext call Encode with context.Context and EncodeOption. +func (e *Encoder) EncodeContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) error { + rctx := encoder.TakeRuntimeContext() + rctx.Option.Flag = 0 + rctx.Option.Flag |= encoder.ContextOption + rctx.Option.Context = ctx + + err := e.encodeWithOption(rctx, v, optFuncs...) //nolint: contextcheck + + encoder.ReleaseRuntimeContext(rctx) + return err +} + +func (e *Encoder) encodeWithOption(ctx *encoder.RuntimeContext, v interface{}, optFuncs ...EncodeOptionFunc) error { + if e.enabledHTMLEscape { + ctx.Option.Flag |= encoder.HTMLEscapeOption + } + ctx.Option.Flag |= encoder.NormalizeUTF8Option + ctx.Option.DebugOut = os.Stdout + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + var ( + buf []byte + err error + ) + if e.enabledIndent { + buf, err = encodeIndent(ctx, v, e.prefix, e.indentStr) + } else { + buf, err = encode(ctx, v) + } + if err != nil { + return err + } + if e.enabledIndent { + buf = buf[:len(buf)-2] + } else { + buf = buf[:len(buf)-1] + } + buf = append(buf, '\n') + if _, err := e.w.Write(buf); err != nil { + return err + } + return nil +} + +// SetEscapeHTML specifies whether problematic HTML characters should be escaped inside JSON quoted strings. +// The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003e to avoid certain safety problems that can arise when embedding JSON in HTML. +// +// In non-HTML settings where the escaping interferes with the readability of the output, SetEscapeHTML(false) disables this behavior. +func (e *Encoder) SetEscapeHTML(on bool) { + e.enabledHTMLEscape = on +} + +// SetIndent instructs the encoder to format each subsequent encoded value as if indented by the package-level function Indent(dst, src, prefix, indent). +// Calling SetIndent("", "") disables indentation. +func (e *Encoder) SetIndent(prefix, indent string) { + if prefix == "" && indent == "" { + e.enabledIndent = false + return + } + e.prefix = prefix + e.indentStr = indent + e.enabledIndent = true +} + +func marshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) { + rctx := encoder.TakeRuntimeContext() + rctx.Option.Flag = 0 + rctx.Option.Flag = encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.ContextOption + rctx.Option.Context = ctx + for _, optFunc := range optFuncs { + optFunc(rctx.Option) + } + + buf, err := encode(rctx, v) //nolint: contextcheck + if err != nil { + encoder.ReleaseRuntimeContext(rctx) + return nil, err + } + + // this line exists to escape call of `runtime.makeslicecopy` . + // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`, + // dst buffer size and src buffer size are differrent. + // in this case, compiler uses `runtime.makeslicecopy`, but it is slow. + buf = buf[:len(buf)-1] + copied := make([]byte, len(buf)) + copy(copied, buf) + + encoder.ReleaseRuntimeContext(rctx) + return copied, nil +} + +func marshal(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) { + ctx := encoder.TakeRuntimeContext() + + ctx.Option.Flag = 0 + ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option) + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + + buf, err := encode(ctx, v) + if err != nil { + encoder.ReleaseRuntimeContext(ctx) + return nil, err + } + + // this line exists to escape call of `runtime.makeslicecopy` . + // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`, + // dst buffer size and src buffer size are differrent. + // in this case, compiler uses `runtime.makeslicecopy`, but it is slow. + buf = buf[:len(buf)-1] + copied := make([]byte, len(buf)) + copy(copied, buf) + + encoder.ReleaseRuntimeContext(ctx) + return copied, nil +} + +func marshalNoEscape(v interface{}) ([]byte, error) { + ctx := encoder.TakeRuntimeContext() + + ctx.Option.Flag = 0 + ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option) + + buf, err := encodeNoEscape(ctx, v) + if err != nil { + encoder.ReleaseRuntimeContext(ctx) + return nil, err + } + + // this line exists to escape call of `runtime.makeslicecopy` . + // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`, + // dst buffer size and src buffer size are differrent. + // in this case, compiler uses `runtime.makeslicecopy`, but it is slow. + buf = buf[:len(buf)-1] + copied := make([]byte, len(buf)) + copy(copied, buf) + + encoder.ReleaseRuntimeContext(ctx) + return copied, nil +} + +func marshalIndent(v interface{}, prefix, indent string, optFuncs ...EncodeOptionFunc) ([]byte, error) { + ctx := encoder.TakeRuntimeContext() + + ctx.Option.Flag = 0 + ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.IndentOption) + for _, optFunc := range optFuncs { + optFunc(ctx.Option) + } + + buf, err := encodeIndent(ctx, v, prefix, indent) + if err != nil { + encoder.ReleaseRuntimeContext(ctx) + return nil, err + } + + buf = buf[:len(buf)-2] + copied := make([]byte, len(buf)) + copy(copied, buf) + + encoder.ReleaseRuntimeContext(ctx) + return copied, nil +} + +func encode(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) { + b := ctx.Buf[:0] + if v == nil { + b = encoder.AppendNull(ctx, b) + b = encoder.AppendComma(ctx, b) + return b, nil + } + header := (*emptyInterface)(unsafe.Pointer(&v)) + typ := header.typ + + typeptr := uintptr(unsafe.Pointer(typ)) + codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr) + if err != nil { + return nil, err + } + + p := uintptr(header.ptr) + ctx.Init(p, codeSet.CodeLength) + ctx.KeepRefs = append(ctx.KeepRefs, header.ptr) + + buf, err := encodeRunCode(ctx, b, codeSet) + if err != nil { + return nil, err + } + ctx.Buf = buf + return buf, nil +} + +func encodeNoEscape(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) { + b := ctx.Buf[:0] + if v == nil { + b = encoder.AppendNull(ctx, b) + b = encoder.AppendComma(ctx, b) + return b, nil + } + header := (*emptyInterface)(unsafe.Pointer(&v)) + typ := header.typ + + typeptr := uintptr(unsafe.Pointer(typ)) + codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr) + if err != nil { + return nil, err + } + + p := uintptr(header.ptr) + ctx.Init(p, codeSet.CodeLength) + buf, err := encodeRunCode(ctx, b, codeSet) + if err != nil { + return nil, err + } + + ctx.Buf = buf + return buf, nil +} + +func encodeIndent(ctx *encoder.RuntimeContext, v interface{}, prefix, indent string) ([]byte, error) { + b := ctx.Buf[:0] + if v == nil { + b = encoder.AppendNull(ctx, b) + b = encoder.AppendCommaIndent(ctx, b) + return b, nil + } + header := (*emptyInterface)(unsafe.Pointer(&v)) + typ := header.typ + + typeptr := uintptr(unsafe.Pointer(typ)) + codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr) + if err != nil { + return nil, err + } + + p := uintptr(header.ptr) + ctx.Init(p, codeSet.CodeLength) + buf, err := encodeRunIndentCode(ctx, b, codeSet, prefix, indent) + + ctx.KeepRefs = append(ctx.KeepRefs, header.ptr) + + if err != nil { + return nil, err + } + + ctx.Buf = buf + return buf, nil +} + +func encodeRunCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + if (ctx.Option.Flag & encoder.DebugOption) != 0 { + if (ctx.Option.Flag & encoder.ColorizeOption) != 0 { + return vm_color.DebugRun(ctx, b, codeSet) + } + return vm.DebugRun(ctx, b, codeSet) + } + if (ctx.Option.Flag & encoder.ColorizeOption) != 0 { + return vm_color.Run(ctx, b, codeSet) + } + return vm.Run(ctx, b, codeSet) +} + +func encodeRunIndentCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, prefix, indent string) ([]byte, error) { + ctx.Prefix = []byte(prefix) + ctx.IndentStr = []byte(indent) + if (ctx.Option.Flag & encoder.DebugOption) != 0 { + if (ctx.Option.Flag & encoder.ColorizeOption) != 0 { + return vm_color_indent.DebugRun(ctx, b, codeSet) + } + return vm_indent.DebugRun(ctx, b, codeSet) + } + if (ctx.Option.Flag & encoder.ColorizeOption) != 0 { + return vm_color_indent.Run(ctx, b, codeSet) + } + return vm_indent.Run(ctx, b, codeSet) +} diff --git a/vendor/github.com/goccy/go-json/error.go b/vendor/github.com/goccy/go-json/error.go new file mode 100644 index 00000000..5b2dcee5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/error.go @@ -0,0 +1,41 @@ +package json + +import ( + "github.com/goccy/go-json/internal/errors" +) + +// Before Go 1.2, an InvalidUTF8Error was returned by Marshal when +// attempting to encode a string value with invalid UTF-8 sequences. +// As of Go 1.2, Marshal instead coerces the string to valid UTF-8 by +// replacing invalid bytes with the Unicode replacement rune U+FFFD. +// +// Deprecated: No longer used; kept for compatibility. +type InvalidUTF8Error = errors.InvalidUTF8Error + +// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. +// (The argument to Unmarshal must be a non-nil pointer.) +type InvalidUnmarshalError = errors.InvalidUnmarshalError + +// A MarshalerError represents an error from calling a MarshalJSON or MarshalText method. +type MarshalerError = errors.MarshalerError + +// A SyntaxError is a description of a JSON syntax error. +type SyntaxError = errors.SyntaxError + +// An UnmarshalFieldError describes a JSON object key that +// led to an unexported (and therefore unwritable) struct field. +// +// Deprecated: No longer used; kept for compatibility. +type UnmarshalFieldError = errors.UnmarshalFieldError + +// An UnmarshalTypeError describes a JSON value that was +// not appropriate for a value of a specific Go type. +type UnmarshalTypeError = errors.UnmarshalTypeError + +// An UnsupportedTypeError is returned by Marshal when attempting +// to encode an unsupported value type. +type UnsupportedTypeError = errors.UnsupportedTypeError + +type UnsupportedValueError = errors.UnsupportedValueError + +type PathError = errors.PathError diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go new file mode 100644 index 00000000..b6876cf0 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go @@ -0,0 +1,41 @@ +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type anonymousFieldDecoder struct { + structType *runtime.Type + offset uintptr + dec Decoder +} + +func newAnonymousFieldDecoder(structType *runtime.Type, offset uintptr, dec Decoder) *anonymousFieldDecoder { + return &anonymousFieldDecoder{ + structType: structType, + offset: offset, + dec: dec, + } +} + +func (d *anonymousFieldDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + if *(*unsafe.Pointer)(p) == nil { + *(*unsafe.Pointer)(p) = unsafe_New(d.structType) + } + p = *(*unsafe.Pointer)(p) + return d.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+d.offset)) +} + +func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + if *(*unsafe.Pointer)(p) == nil { + *(*unsafe.Pointer)(p) = unsafe_New(d.structType) + } + p = *(*unsafe.Pointer)(p) + return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset)) +} + +func (d *anonymousFieldDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return d.dec.DecodePath(ctx, cursor, depth) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go new file mode 100644 index 00000000..4b23ed43 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/array.go @@ -0,0 +1,176 @@ +package decoder + +import ( + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type arrayDecoder struct { + elemType *runtime.Type + size uintptr + valueDecoder Decoder + alen int + structName string + fieldName string + zeroValue unsafe.Pointer +} + +func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder { + // workaround to avoid checkptr errors. cannot use `*(*unsafe.Pointer)(unsafe_New(elemType))` directly. + zeroValuePtr := unsafe_New(elemType) + zeroValue := **(**unsafe.Pointer)(unsafe.Pointer(&zeroValuePtr)) + return &arrayDecoder{ + valueDecoder: dec, + elemType: elemType, + size: elemType.Size(), + alen: alen, + structName: structName, + fieldName: fieldName, + zeroValue: zeroValue, + } +} + +func (d *arrayDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + case '[': + idx := 0 + s.cursor++ + if s.skipWhiteSpace() == ']' { + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + s.cursor++ + return nil + } + for { + if idx < d.alen { + if err := d.valueDecoder.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)); err != nil { + return err + } + } else { + if err := s.skipValue(depth); err != nil { + return err + } + } + idx++ + switch s.skipWhiteSpace() { + case ']': + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + s.cursor++ + return nil + case ',': + s.cursor++ + continue + case nul: + if s.read() { + s.cursor++ + continue + } + goto ERROR + default: + goto ERROR + } + } + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + s.cursor++ + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("array", s.totalOffset()) +} + +func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case '[': + idx := 0 + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == ']' { + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + cursor++ + return cursor, nil + } + for { + if idx < d.alen { + c, err := d.valueDecoder.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)) + if err != nil { + return 0, err + } + cursor = c + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } + idx++ + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case ']': + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + cursor++ + return cursor, nil + case ',': + cursor++ + continue + default: + return 0, errors.ErrInvalidCharacter(buf[cursor], "array", cursor) + } + } + default: + return 0, errors.ErrUnexpectedEndOfJSON("array", cursor) + } + } +} + +func (d *arrayDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: array decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go new file mode 100644 index 00000000..c53e6ad9 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/assign.go @@ -0,0 +1,438 @@ +package decoder + +import ( + "fmt" + "reflect" + "strconv" +) + +var ( + nilValue = reflect.ValueOf(nil) +) + +func AssignValue(src, dst reflect.Value) error { + if dst.Type().Kind() != reflect.Ptr { + return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type()) + } + casted, err := castValue(dst.Elem().Type(), src) + if err != nil { + return err + } + dst.Elem().Set(casted) + return nil +} + +func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) { + switch t.Kind() { + case reflect.Int: + vv, err := castInt(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(int(vv.Int())), nil + case reflect.Int8: + vv, err := castInt(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(int8(vv.Int())), nil + case reflect.Int16: + vv, err := castInt(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(int16(vv.Int())), nil + case reflect.Int32: + vv, err := castInt(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(int32(vv.Int())), nil + case reflect.Int64: + return castInt(v) + case reflect.Uint: + vv, err := castUint(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(uint(vv.Uint())), nil + case reflect.Uint8: + vv, err := castUint(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(uint8(vv.Uint())), nil + case reflect.Uint16: + vv, err := castUint(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(uint16(vv.Uint())), nil + case reflect.Uint32: + vv, err := castUint(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(uint32(vv.Uint())), nil + case reflect.Uint64: + return castUint(v) + case reflect.Uintptr: + vv, err := castUint(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(uintptr(vv.Uint())), nil + case reflect.String: + return castString(v) + case reflect.Bool: + return castBool(v) + case reflect.Float32: + vv, err := castFloat(v) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(float32(vv.Float())), nil + case reflect.Float64: + return castFloat(v) + case reflect.Array: + return castArray(t, v) + case reflect.Slice: + return castSlice(t, v) + case reflect.Map: + return castMap(t, v) + case reflect.Struct: + return castStruct(t, v) + } + return v, nil +} + +func castInt(v reflect.Value) (reflect.Value, error) { + switch v.Type().Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v, nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return reflect.ValueOf(int64(v.Uint())), nil + case reflect.String: + i64, err := strconv.ParseInt(v.String(), 10, 64) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(i64), nil + case reflect.Bool: + if v.Bool() { + return reflect.ValueOf(int64(1)), nil + } + return reflect.ValueOf(int64(0)), nil + case reflect.Float32, reflect.Float64: + return reflect.ValueOf(int64(v.Float())), nil + case reflect.Array: + if v.Len() > 0 { + return castInt(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to int64 from empty array") + case reflect.Slice: + if v.Len() > 0 { + return castInt(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to int64 from empty slice") + case reflect.Interface: + return castInt(reflect.ValueOf(v.Interface())) + case reflect.Map: + return nilValue, fmt.Errorf("failed to cast to int64 from map") + case reflect.Struct: + return nilValue, fmt.Errorf("failed to cast to int64 from struct") + case reflect.Ptr: + return castInt(v.Elem()) + } + return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind()) +} + +func castUint(v reflect.Value) (reflect.Value, error) { + switch v.Type().Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return reflect.ValueOf(uint64(v.Int())), nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v, nil + case reflect.String: + u64, err := strconv.ParseUint(v.String(), 10, 64) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(u64), nil + case reflect.Bool: + if v.Bool() { + return reflect.ValueOf(uint64(1)), nil + } + return reflect.ValueOf(uint64(0)), nil + case reflect.Float32, reflect.Float64: + return reflect.ValueOf(uint64(v.Float())), nil + case reflect.Array: + if v.Len() > 0 { + return castUint(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to uint64 from empty array") + case reflect.Slice: + if v.Len() > 0 { + return castUint(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice") + case reflect.Interface: + return castUint(reflect.ValueOf(v.Interface())) + case reflect.Map: + return nilValue, fmt.Errorf("failed to cast to uint64 from map") + case reflect.Struct: + return nilValue, fmt.Errorf("failed to cast to uint64 from struct") + case reflect.Ptr: + return castUint(v.Elem()) + } + return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind()) +} + +func castString(v reflect.Value) (reflect.Value, error) { + switch v.Type().Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return reflect.ValueOf(fmt.Sprint(v.Int())), nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return reflect.ValueOf(fmt.Sprint(v.Uint())), nil + case reflect.String: + return v, nil + case reflect.Bool: + if v.Bool() { + return reflect.ValueOf("true"), nil + } + return reflect.ValueOf("false"), nil + case reflect.Float32, reflect.Float64: + return reflect.ValueOf(fmt.Sprint(v.Float())), nil + case reflect.Array: + if v.Len() > 0 { + return castString(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to string from empty array") + case reflect.Slice: + if v.Len() > 0 { + return castString(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to string from empty slice") + case reflect.Interface: + return castString(reflect.ValueOf(v.Interface())) + case reflect.Map: + return nilValue, fmt.Errorf("failed to cast to string from map") + case reflect.Struct: + return nilValue, fmt.Errorf("failed to cast to string from struct") + case reflect.Ptr: + return castString(v.Elem()) + } + return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind()) +} + +func castBool(v reflect.Value) (reflect.Value, error) { + switch v.Type().Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + switch v.Int() { + case 0: + return reflect.ValueOf(false), nil + case 1: + return reflect.ValueOf(true), nil + } + return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int()) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + switch v.Uint() { + case 0: + return reflect.ValueOf(false), nil + case 1: + return reflect.ValueOf(true), nil + } + return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint()) + case reflect.String: + b, err := strconv.ParseBool(v.String()) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(b), nil + case reflect.Bool: + return v, nil + case reflect.Float32, reflect.Float64: + switch v.Float() { + case 0: + return reflect.ValueOf(false), nil + case 1: + return reflect.ValueOf(true), nil + } + return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float()) + case reflect.Array: + if v.Len() > 0 { + return castBool(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to string from empty array") + case reflect.Slice: + if v.Len() > 0 { + return castBool(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to string from empty slice") + case reflect.Interface: + return castBool(reflect.ValueOf(v.Interface())) + case reflect.Map: + return nilValue, fmt.Errorf("failed to cast to string from map") + case reflect.Struct: + return nilValue, fmt.Errorf("failed to cast to string from struct") + case reflect.Ptr: + return castBool(v.Elem()) + } + return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind()) +} + +func castFloat(v reflect.Value) (reflect.Value, error) { + switch v.Type().Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return reflect.ValueOf(float64(v.Int())), nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return reflect.ValueOf(float64(v.Uint())), nil + case reflect.String: + f64, err := strconv.ParseFloat(v.String(), 64) + if err != nil { + return nilValue, err + } + return reflect.ValueOf(f64), nil + case reflect.Bool: + if v.Bool() { + return reflect.ValueOf(float64(1)), nil + } + return reflect.ValueOf(float64(0)), nil + case reflect.Float32, reflect.Float64: + return v, nil + case reflect.Array: + if v.Len() > 0 { + return castFloat(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to float64 from empty array") + case reflect.Slice: + if v.Len() > 0 { + return castFloat(v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to float64 from empty slice") + case reflect.Interface: + return castFloat(reflect.ValueOf(v.Interface())) + case reflect.Map: + return nilValue, fmt.Errorf("failed to cast to float64 from map") + case reflect.Struct: + return nilValue, fmt.Errorf("failed to cast to float64 from struct") + case reflect.Ptr: + return castFloat(v.Elem()) + } + return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind()) +} + +func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) { + kind := v.Type().Kind() + if kind == reflect.Interface { + return castArray(t, reflect.ValueOf(v.Interface())) + } + if kind != reflect.Slice && kind != reflect.Array { + return nilValue, fmt.Errorf("failed to cast to array from %s", kind) + } + if t.Elem() == v.Type().Elem() { + return v, nil + } + if t.Len() != v.Len() { + return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len()) + } + ret := reflect.New(t).Elem() + for i := 0; i < v.Len(); i++ { + vv, err := castValue(t.Elem(), v.Index(i)) + if err != nil { + return nilValue, err + } + ret.Index(i).Set(vv) + } + return ret, nil +} + +func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) { + kind := v.Type().Kind() + if kind == reflect.Interface { + return castSlice(t, reflect.ValueOf(v.Interface())) + } + if kind != reflect.Slice && kind != reflect.Array { + return nilValue, fmt.Errorf("failed to cast to slice from %s", kind) + } + if t.Elem() == v.Type().Elem() { + return v, nil + } + ret := reflect.MakeSlice(t, v.Len(), v.Len()) + for i := 0; i < v.Len(); i++ { + vv, err := castValue(t.Elem(), v.Index(i)) + if err != nil { + return nilValue, err + } + ret.Index(i).Set(vv) + } + return ret, nil +} + +func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) { + ret := reflect.MakeMap(t) + switch v.Type().Kind() { + case reflect.Map: + iter := v.MapRange() + for iter.Next() { + key, err := castValue(t.Key(), iter.Key()) + if err != nil { + return nilValue, err + } + value, err := castValue(t.Elem(), iter.Value()) + if err != nil { + return nilValue, err + } + ret.SetMapIndex(key, value) + } + return ret, nil + case reflect.Interface: + return castMap(t, reflect.ValueOf(v.Interface())) + case reflect.Slice: + if v.Len() > 0 { + return castMap(t, v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to map from empty slice") + } + return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind()) +} + +func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) { + ret := reflect.New(t).Elem() + switch v.Type().Kind() { + case reflect.Map: + iter := v.MapRange() + for iter.Next() { + key := iter.Key() + k, err := castString(key) + if err != nil { + return nilValue, err + } + fieldName := k.String() + field, ok := t.FieldByName(fieldName) + if ok { + value, err := castValue(field.Type, iter.Value()) + if err != nil { + return nilValue, err + } + ret.FieldByName(fieldName).Set(value) + } + } + return ret, nil + case reflect.Struct: + for i := 0; i < v.Type().NumField(); i++ { + name := v.Type().Field(i).Name + ret.FieldByName(name).Set(v.FieldByName(name)) + } + return ret, nil + case reflect.Interface: + return castStruct(t, reflect.ValueOf(v.Interface())) + case reflect.Slice: + if v.Len() > 0 { + return castStruct(t, v.Index(0)) + } + return nilValue, fmt.Errorf("failed to cast to struct from empty slice") + default: + return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind()) + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go new file mode 100644 index 00000000..ba6cf5bc --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/bool.go @@ -0,0 +1,83 @@ +package decoder + +import ( + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type boolDecoder struct { + structName string + fieldName string +} + +func newBoolDecoder(structName, fieldName string) *boolDecoder { + return &boolDecoder{structName: structName, fieldName: fieldName} +} + +func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + c := s.skipWhiteSpace() + for { + switch c { + case 't': + if err := trueBytes(s); err != nil { + return err + } + **(**bool)(unsafe.Pointer(&p)) = true + return nil + case 'f': + if err := falseBytes(s); err != nil { + return err + } + **(**bool)(unsafe.Pointer(&p)) = false + return nil + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + case nul: + if s.read() { + c = s.char() + continue + } + goto ERROR + } + break + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("bool", s.totalOffset()) +} + +func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**bool)(unsafe.Pointer(&p)) = true + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + **(**bool)(unsafe.Pointer(&p)) = false + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + } + return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor) +} + +func (d *boolDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: bool decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go new file mode 100644 index 00000000..939bf432 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go @@ -0,0 +1,118 @@ +package decoder + +import ( + "encoding/base64" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type bytesDecoder struct { + typ *runtime.Type + sliceDecoder Decoder + stringDecoder *stringDecoder + structName string + fieldName string +} + +func byteUnmarshalerSliceDecoder(typ *runtime.Type, structName string, fieldName string) Decoder { + var unmarshalDecoder Decoder + switch { + case runtime.PtrTo(typ).Implements(unmarshalJSONType): + unmarshalDecoder = newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName) + case runtime.PtrTo(typ).Implements(unmarshalTextType): + unmarshalDecoder = newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName) + default: + unmarshalDecoder, _ = compileUint8(typ, structName, fieldName) + } + return newSliceDecoder(unmarshalDecoder, typ, 1, structName, fieldName) +} + +func newBytesDecoder(typ *runtime.Type, structName string, fieldName string) *bytesDecoder { + return &bytesDecoder{ + typ: typ, + sliceDecoder: byteUnmarshalerSliceDecoder(typ, structName, fieldName), + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + } +} + +func (d *bytesDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamBinary(s, depth, p) + if err != nil { + return err + } + if bytes == nil { + s.reset() + return nil + } + decodedLen := base64.StdEncoding.DecodedLen(len(bytes)) + buf := make([]byte, decodedLen) + n, err := base64.StdEncoding.Decode(buf, bytes) + if err != nil { + return err + } + *(*[]byte)(p) = buf[:n] + s.reset() + return nil +} + +func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeBinary(ctx, cursor, depth, p) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + decodedLen := base64.StdEncoding.DecodedLen(len(bytes)) + b := make([]byte, decodedLen) + n, err := base64.StdEncoding.Decode(b, bytes) + if err != nil { + return 0, err + } + *(*[]byte)(p) = b[:n] + return cursor, nil +} + +func (d *bytesDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: []byte decoder does not support decode path") +} + +func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) { + c := s.skipWhiteSpace() + if c == '[' { + if d.sliceDecoder == nil { + return nil, &errors.UnmarshalTypeError{ + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + err := d.sliceDecoder.DecodeStream(s, depth, p) + return nil, err + } + return d.stringDecoder.decodeStreamByte(s) +} + +func (d *bytesDecoder) decodeBinary(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) ([]byte, int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '[' { + if d.sliceDecoder == nil { + return nil, 0, &errors.UnmarshalTypeError{ + Type: runtime.RType2Type(d.typ), + Offset: cursor, + } + } + c, err := d.sliceDecoder.Decode(ctx, cursor, depth, p) + if err != nil { + return nil, 0, err + } + return nil, c, nil + } + return d.stringDecoder.decodeByte(buf, cursor) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile.go b/vendor/github.com/goccy/go-json/internal/decoder/compile.go new file mode 100644 index 00000000..8ad50936 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile.go @@ -0,0 +1,493 @@ +package decoder + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "sync" + "sync/atomic" + "unicode" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +var ( + jsonNumberType = reflect.TypeOf(json.Number("")) + typeAddr *runtime.TypeAddr + cachedDecoderMap unsafe.Pointer // map[uintptr]decoder + cachedDecoder []Decoder + initOnce sync.Once +) + +func initDecoder() { + initOnce.Do(func() { + typeAddr = runtime.AnalyzeTypeAddr() + if typeAddr == nil { + typeAddr = &runtime.TypeAddr{} + } + cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift+1) + }) +} + +func loadDecoderMap() map[uintptr]Decoder { + initDecoder() + p := atomic.LoadPointer(&cachedDecoderMap) + return *(*map[uintptr]Decoder)(unsafe.Pointer(&p)) +} + +func storeDecoder(typ uintptr, dec Decoder, m map[uintptr]Decoder) { + initDecoder() + newDecoderMap := make(map[uintptr]Decoder, len(m)+1) + newDecoderMap[typ] = dec + + for k, v := range m { + newDecoderMap[k] = v + } + + atomic.StorePointer(&cachedDecoderMap, *(*unsafe.Pointer)(unsafe.Pointer(&newDecoderMap))) +} + +func compileToGetDecoderSlowPath(typeptr uintptr, typ *runtime.Type) (Decoder, error) { + decoderMap := loadDecoderMap() + if dec, exists := decoderMap[typeptr]; exists { + return dec, nil + } + + dec, err := compileHead(typ, map[uintptr]Decoder{}) + if err != nil { + return nil, err + } + storeDecoder(typeptr, dec, decoderMap) + return dec, nil +} + +func compileHead(typ *runtime.Type, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + switch { + case implementsUnmarshalJSONType(runtime.PtrTo(typ)): + return newUnmarshalJSONDecoder(runtime.PtrTo(typ), "", ""), nil + case runtime.PtrTo(typ).Implements(unmarshalTextType): + return newUnmarshalTextDecoder(runtime.PtrTo(typ), "", ""), nil + } + return compile(typ.Elem(), "", "", structTypeToDecoder) +} + +func compile(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + switch { + case implementsUnmarshalJSONType(runtime.PtrTo(typ)): + return newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName), nil + case runtime.PtrTo(typ).Implements(unmarshalTextType): + return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil + } + + switch typ.Kind() { + case reflect.Ptr: + return compilePtr(typ, structName, fieldName, structTypeToDecoder) + case reflect.Struct: + return compileStruct(typ, structName, fieldName, structTypeToDecoder) + case reflect.Slice: + elem := typ.Elem() + if elem.Kind() == reflect.Uint8 { + return compileBytes(elem, structName, fieldName) + } + return compileSlice(typ, structName, fieldName, structTypeToDecoder) + case reflect.Array: + return compileArray(typ, structName, fieldName, structTypeToDecoder) + case reflect.Map: + return compileMap(typ, structName, fieldName, structTypeToDecoder) + case reflect.Interface: + return compileInterface(typ, structName, fieldName) + case reflect.Uintptr: + return compileUint(typ, structName, fieldName) + case reflect.Int: + return compileInt(typ, structName, fieldName) + case reflect.Int8: + return compileInt8(typ, structName, fieldName) + case reflect.Int16: + return compileInt16(typ, structName, fieldName) + case reflect.Int32: + return compileInt32(typ, structName, fieldName) + case reflect.Int64: + return compileInt64(typ, structName, fieldName) + case reflect.Uint: + return compileUint(typ, structName, fieldName) + case reflect.Uint8: + return compileUint8(typ, structName, fieldName) + case reflect.Uint16: + return compileUint16(typ, structName, fieldName) + case reflect.Uint32: + return compileUint32(typ, structName, fieldName) + case reflect.Uint64: + return compileUint64(typ, structName, fieldName) + case reflect.String: + return compileString(typ, structName, fieldName) + case reflect.Bool: + return compileBool(structName, fieldName) + case reflect.Float32: + return compileFloat32(structName, fieldName) + case reflect.Float64: + return compileFloat64(structName, fieldName) + case reflect.Func: + return compileFunc(typ, structName, fieldName) + } + return newInvalidDecoder(typ, structName, fieldName), nil +} + +func isStringTagSupportedType(typ *runtime.Type) bool { + switch { + case implementsUnmarshalJSONType(runtime.PtrTo(typ)): + return false + case runtime.PtrTo(typ).Implements(unmarshalTextType): + return false + } + switch typ.Kind() { + case reflect.Map: + return false + case reflect.Slice: + return false + case reflect.Array: + return false + case reflect.Struct: + return false + case reflect.Interface: + return false + } + return true +} + +func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + if runtime.PtrTo(typ).Implements(unmarshalTextType) { + return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil + } + if typ.Kind() == reflect.String { + return newStringDecoder(structName, fieldName), nil + } + dec, err := compile(typ, structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + for { + switch t := dec.(type) { + case *stringDecoder, *interfaceDecoder: + return dec, nil + case *boolDecoder, *intDecoder, *uintDecoder, *numberDecoder: + return newWrappedStringDecoder(typ, dec, structName, fieldName), nil + case *ptrDecoder: + dec = t.dec + default: + return newInvalidDecoder(typ, structName, fieldName), nil + } + } +} + +func compilePtr(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + dec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + return newPtrDecoder(dec, typ.Elem(), structName, fieldName), nil +} + +func compileInt(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { + *(*int)(p) = int(v) + }), nil +} + +func compileInt8(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { + *(*int8)(p) = int8(v) + }), nil +} + +func compileInt16(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { + *(*int16)(p) = int16(v) + }), nil +} + +func compileInt32(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { + *(*int32)(p) = int32(v) + }), nil +} + +func compileInt64(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { + *(*int64)(p) = v + }), nil +} + +func compileUint(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { + *(*uint)(p) = uint(v) + }), nil +} + +func compileUint8(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { + *(*uint8)(p) = uint8(v) + }), nil +} + +func compileUint16(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { + *(*uint16)(p) = uint16(v) + }), nil +} + +func compileUint32(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { + *(*uint32)(p) = uint32(v) + }), nil +} + +func compileUint64(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { + *(*uint64)(p) = v + }), nil +} + +func compileFloat32(structName, fieldName string) (Decoder, error) { + return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*float32)(p) = float32(v) + }), nil +} + +func compileFloat64(structName, fieldName string) (Decoder, error) { + return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*float64)(p) = v + }), nil +} + +func compileString(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + if typ == runtime.Type2RType(jsonNumberType) { + return newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) { + *(*json.Number)(p) = v + }), nil + } + return newStringDecoder(structName, fieldName), nil +} + +func compileBool(structName, fieldName string) (Decoder, error) { + return newBoolDecoder(structName, fieldName), nil +} + +func compileBytes(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newBytesDecoder(typ, structName, fieldName), nil +} + +func compileSlice(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + elem := typ.Elem() + decoder, err := compile(elem, structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + return newSliceDecoder(decoder, elem, elem.Size(), structName, fieldName), nil +} + +func compileArray(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + elem := typ.Elem() + decoder, err := compile(elem, structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + return newArrayDecoder(decoder, elem, typ.Len(), structName, fieldName), nil +} + +func compileMap(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + keyDec, err := compileMapKey(typ.Key(), structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + valueDec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder) + if err != nil { + return nil, err + } + return newMapDecoder(typ, typ.Key(), keyDec, typ.Elem(), valueDec, structName, fieldName), nil +} + +func compileInterface(typ *runtime.Type, structName, fieldName string) (Decoder, error) { + return newInterfaceDecoder(typ, structName, fieldName), nil +} + +func compileFunc(typ *runtime.Type, strutName, fieldName string) (Decoder, error) { + return newFuncDecoder(typ, strutName, fieldName), nil +} + +func typeToStructTags(typ *runtime.Type) runtime.StructTags { + tags := runtime.StructTags{} + fieldNum := typ.NumField() + for i := 0; i < fieldNum; i++ { + field := typ.Field(i) + if runtime.IsIgnoredStructField(field) { + continue + } + tags = append(tags, runtime.StructTagFromField(field)) + } + return tags +} + +func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) { + fieldNum := typ.NumField() + fieldMap := map[string]*structFieldSet{} + typeptr := uintptr(unsafe.Pointer(typ)) + if dec, exists := structTypeToDecoder[typeptr]; exists { + return dec, nil + } + structDec := newStructDecoder(structName, fieldName, fieldMap) + structTypeToDecoder[typeptr] = structDec + structName = typ.Name() + tags := typeToStructTags(typ) + allFields := []*structFieldSet{} + for i := 0; i < fieldNum; i++ { + field := typ.Field(i) + if runtime.IsIgnoredStructField(field) { + continue + } + isUnexportedField := unicode.IsLower([]rune(field.Name)[0]) + tag := runtime.StructTagFromField(field) + dec, err := compile(runtime.Type2RType(field.Type), structName, field.Name, structTypeToDecoder) + if err != nil { + return nil, err + } + if field.Anonymous && !tag.IsTaggedKey { + if stDec, ok := dec.(*structDecoder); ok { + if runtime.Type2RType(field.Type) == typ { + // recursive definition + continue + } + for k, v := range stDec.fieldMap { + if tags.ExistsKey(k) { + continue + } + fieldSet := &structFieldSet{ + dec: v.dec, + offset: field.Offset + v.offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + } + allFields = append(allFields, fieldSet) + } + } else if pdec, ok := dec.(*ptrDecoder); ok { + contentDec := pdec.contentDecoder() + if pdec.typ == typ { + // recursive definition + continue + } + var fieldSetErr error + if isUnexportedField { + fieldSetErr = fmt.Errorf( + "json: cannot set embedded pointer to unexported struct: %v", + field.Type.Elem(), + ) + } + if dec, ok := contentDec.(*structDecoder); ok { + for k, v := range dec.fieldMap { + if tags.ExistsKey(k) { + continue + } + fieldSet := &structFieldSet{ + dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec), + offset: field.Offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + err: fieldSetErr, + } + allFields = append(allFields, fieldSet) + } + } else { + fieldSet := &structFieldSet{ + dec: pdec, + offset: field.Offset, + isTaggedKey: tag.IsTaggedKey, + key: field.Name, + keyLen: int64(len(field.Name)), + } + allFields = append(allFields, fieldSet) + } + } else { + fieldSet := &structFieldSet{ + dec: dec, + offset: field.Offset, + isTaggedKey: tag.IsTaggedKey, + key: field.Name, + keyLen: int64(len(field.Name)), + } + allFields = append(allFields, fieldSet) + } + } else { + if tag.IsString && isStringTagSupportedType(runtime.Type2RType(field.Type)) { + dec = newWrappedStringDecoder(runtime.Type2RType(field.Type), dec, structName, field.Name) + } + var key string + if tag.Key != "" { + key = tag.Key + } else { + key = field.Name + } + fieldSet := &structFieldSet{ + dec: dec, + offset: field.Offset, + isTaggedKey: tag.IsTaggedKey, + key: key, + keyLen: int64(len(key)), + } + allFields = append(allFields, fieldSet) + } + } + for _, set := range filterDuplicatedFields(allFields) { + fieldMap[set.key] = set + lower := strings.ToLower(set.key) + if _, exists := fieldMap[lower]; !exists { + // first win + fieldMap[lower] = set + } + } + delete(structTypeToDecoder, typeptr) + structDec.tryOptimize() + return structDec, nil +} + +func filterDuplicatedFields(allFields []*structFieldSet) []*structFieldSet { + fieldMap := map[string][]*structFieldSet{} + for _, field := range allFields { + fieldMap[field.key] = append(fieldMap[field.key], field) + } + duplicatedFieldMap := map[string]struct{}{} + for k, sets := range fieldMap { + sets = filterFieldSets(sets) + if len(sets) != 1 { + duplicatedFieldMap[k] = struct{}{} + } + } + + filtered := make([]*structFieldSet, 0, len(allFields)) + for _, field := range allFields { + if _, exists := duplicatedFieldMap[field.key]; exists { + continue + } + filtered = append(filtered, field) + } + return filtered +} + +func filterFieldSets(sets []*structFieldSet) []*structFieldSet { + if len(sets) == 1 { + return sets + } + filtered := make([]*structFieldSet, 0, len(sets)) + for _, set := range sets { + if set.isTaggedKey { + filtered = append(filtered, set) + } + } + return filtered +} + +func implementsUnmarshalJSONType(typ *runtime.Type) bool { + return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go new file mode 100644 index 00000000..025ca85b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go @@ -0,0 +1,30 @@ +//go:build !race +// +build !race + +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) { + initDecoder() + typeptr := uintptr(unsafe.Pointer(typ)) + if typeptr > typeAddr.MaxTypeAddr { + return compileToGetDecoderSlowPath(typeptr, typ) + } + + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + if dec := cachedDecoder[index]; dec != nil { + return dec, nil + } + + dec, err := compileHead(typ, map[uintptr]Decoder{}) + if err != nil { + return nil, err + } + cachedDecoder[index] = dec + return dec, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go new file mode 100644 index 00000000..023b817c --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go @@ -0,0 +1,38 @@ +//go:build race +// +build race + +package decoder + +import ( + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +var decMu sync.RWMutex + +func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) { + initDecoder() + typeptr := uintptr(unsafe.Pointer(typ)) + if typeptr > typeAddr.MaxTypeAddr { + return compileToGetDecoderSlowPath(typeptr, typ) + } + + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + decMu.RLock() + if dec := cachedDecoder[index]; dec != nil { + decMu.RUnlock() + return dec, nil + } + decMu.RUnlock() + + dec, err := compileHead(typ, map[uintptr]Decoder{}) + if err != nil { + return nil, err + } + decMu.Lock() + cachedDecoder[index] = dec + decMu.Unlock() + return dec, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/context.go b/vendor/github.com/goccy/go-json/internal/decoder/context.go new file mode 100644 index 00000000..cb2ffdaf --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/context.go @@ -0,0 +1,254 @@ +package decoder + +import ( + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type RuntimeContext struct { + Buf []byte + Option *Option +} + +var ( + runtimeContextPool = sync.Pool{ + New: func() interface{} { + return &RuntimeContext{ + Option: &Option{}, + } + }, + } +) + +func TakeRuntimeContext() *RuntimeContext { + return runtimeContextPool.Get().(*RuntimeContext) +} + +func ReleaseRuntimeContext(ctx *RuntimeContext) { + runtimeContextPool.Put(ctx) +} + +var ( + isWhiteSpace = [256]bool{} +) + +func init() { + isWhiteSpace[' '] = true + isWhiteSpace['\n'] = true + isWhiteSpace['\t'] = true + isWhiteSpace['\r'] = true +} + +func char(ptr unsafe.Pointer, offset int64) byte { + return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset))) +} + +func skipWhiteSpace(buf []byte, cursor int64) int64 { + for isWhiteSpace[buf[cursor]] { + cursor++ + } + return cursor +} + +func skipObject(buf []byte, cursor, depth int64) (int64, error) { + braceCount := 1 + for { + switch buf[cursor] { + case '{': + braceCount++ + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case '}': + depth-- + braceCount-- + if braceCount == 0 { + return cursor + 1, nil + } + case '[': + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case ']': + depth-- + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("object of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func skipArray(buf []byte, cursor, depth int64) (int64, error) { + bracketCount := 1 + for { + switch buf[cursor] { + case '[': + bracketCount++ + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case ']': + bracketCount-- + depth-- + if bracketCount == 0 { + return cursor + 1, nil + } + case '{': + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case '}': + depth-- + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("array of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func skipValue(buf []byte, cursor, depth int64) (int64, error) { + for { + switch buf[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case '{': + return skipObject(buf, cursor+1, depth+1) + case '[': + return skipArray(buf, cursor+1, depth+1) + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + return cursor + 1, nil + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + for { + cursor++ + if floatTable[buf[cursor]] { + continue + } + break + } + return cursor, nil + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + default: + return cursor, errors.ErrUnexpectedEndOfJSON("null", cursor) + } + } +} + +func validateTrue(buf []byte, cursor int64) error { + if cursor+3 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("true", cursor) + } + if buf[cursor+1] != 'r' { + return errors.ErrInvalidCharacter(buf[cursor+1], "true", cursor) + } + if buf[cursor+2] != 'u' { + return errors.ErrInvalidCharacter(buf[cursor+2], "true", cursor) + } + if buf[cursor+3] != 'e' { + return errors.ErrInvalidCharacter(buf[cursor+3], "true", cursor) + } + return nil +} + +func validateFalse(buf []byte, cursor int64) error { + if cursor+4 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("false", cursor) + } + if buf[cursor+1] != 'a' { + return errors.ErrInvalidCharacter(buf[cursor+1], "false", cursor) + } + if buf[cursor+2] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+2], "false", cursor) + } + if buf[cursor+3] != 's' { + return errors.ErrInvalidCharacter(buf[cursor+3], "false", cursor) + } + if buf[cursor+4] != 'e' { + return errors.ErrInvalidCharacter(buf[cursor+4], "false", cursor) + } + return nil +} + +func validateNull(buf []byte, cursor int64) error { + if cursor+3 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("null", cursor) + } + if buf[cursor+1] != 'u' { + return errors.ErrInvalidCharacter(buf[cursor+1], "null", cursor) + } + if buf[cursor+2] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+2], "null", cursor) + } + if buf[cursor+3] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+3], "null", cursor) + } + return nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go new file mode 100644 index 00000000..9b2eb8b3 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/float.go @@ -0,0 +1,170 @@ +package decoder + +import ( + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type floatDecoder struct { + op func(unsafe.Pointer, float64) + structName string + fieldName string +} + +func newFloatDecoder(structName, fieldName string, op func(unsafe.Pointer, float64)) *floatDecoder { + return &floatDecoder{op: op, structName: structName, fieldName: fieldName} +} + +var ( + floatTable = [256]bool{ + '0': true, + '1': true, + '2': true, + '3': true, + '4': true, + '5': true, + '6': true, + '7': true, + '8': true, + '9': true, + '.': true, + 'e': true, + 'E': true, + '+': true, + '-': true, + } + + validEndNumberChar = [256]bool{ + nul: true, + ' ': true, + '\t': true, + '\r': true, + '\n': true, + ',': true, + ':': true, + '}': true, + ']': true, + } +) + +func floatBytes(s *Stream) []byte { + start := s.cursor + for { + s.cursor++ + if floatTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + return s.buf[start:s.cursor] +} + +func (d *floatDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return floatBytes(s), nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("float", s.totalOffset()) +} + +func (d *floatDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for floatTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("float", cursor) + } + } +} + +func (d *floatDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + str := *(*string)(unsafe.Pointer(&bytes)) + f64, err := strconv.ParseFloat(str, 64) + if err != nil { + return errors.ErrSyntax(err.Error(), s.totalOffset()) + } + d.op(p, f64) + return nil +} + +func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + bytes, c, err := d.decodeByte(buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + if !validEndNumberChar[buf[cursor]] { + return 0, errors.ErrUnexpectedEndOfJSON("float", cursor) + } + s := *(*string)(unsafe.Pointer(&bytes)) + f64, err := strconv.ParseFloat(s, 64) + if err != nil { + return 0, errors.ErrSyntax(err.Error(), cursor) + } + d.op(p, f64) + return cursor, nil +} + +func (d *floatDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + buf := ctx.Buf + bytes, c, err := d.decodeByte(buf, cursor) + if err != nil { + return nil, 0, err + } + if bytes == nil { + return [][]byte{nullbytes}, c, nil + } + return [][]byte{bytes}, c, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go new file mode 100644 index 00000000..4cc12ca8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/func.go @@ -0,0 +1,146 @@ +package decoder + +import ( + "bytes" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type funcDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newFuncDecoder(typ *runtime.Type, structName, fieldName string) *funcDecoder { + fnDecoder := &funcDecoder{typ, structName, fieldName} + return fnDecoder +} + +func (d *funcDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if len(src) > 0 { + switch src[0] { + case '"': + return &errors.UnmarshalTypeError{ + Value: "string", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '[': + return &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '{': + return &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case 'n': + if err := nullBytes(s); err != nil { + return err + } + *(*unsafe.Pointer)(p) = nil + return nil + case 't': + if err := trueBytes(s); err == nil { + return &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + case 'f': + if err := falseBytes(s); err == nil { + return &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + } + } + return errors.ErrInvalidBeginningOfValue(s.buf[s.cursor], s.totalOffset()) +} + +func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if len(src) > 0 { + switch src[0] { + case '"': + return 0, &errors.UnmarshalTypeError{ + Value: "string", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '[': + return 0, &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '{': + return 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + case 't': + if err := validateTrue(buf, start); err == nil { + return 0, &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + } + case 'f': + if err := validateFalse(buf, start); err == nil { + return 0, &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + } + } + } + return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) +} + +func (d *funcDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: func decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go new file mode 100644 index 00000000..1a7f0819 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/int.go @@ -0,0 +1,246 @@ +package decoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type intDecoder struct { + typ *runtime.Type + kind reflect.Kind + op func(unsafe.Pointer, int64) + structName string + fieldName string +} + +func newIntDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, int64)) *intDecoder { + return &intDecoder{ + typ: typ, + kind: typ.Kind(), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *intDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: fmt.Sprintf("number %s", string(buf)), + Type: runtime.RType2Type(d.typ), + Struct: d.structName, + Field: d.fieldName, + Offset: offset, + } +} + +var ( + pow10i64 = [...]int64{ + 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, + } + pow10i64Len = len(pow10i64) +) + +func (d *intDecoder) parseInt(b []byte) (int64, error) { + isNegative := false + if b[0] == '-' { + b = b[1:] + isNegative = true + } + maxDigit := len(b) + if maxDigit > pow10i64Len { + return 0, fmt.Errorf("invalid length of number") + } + sum := int64(0) + for i := 0; i < maxDigit; i++ { + c := int64(b[i]) - 48 + digitValue := pow10i64[maxDigit-i-1] + sum += c * digitValue + } + if isNegative { + return -1 * sum, nil + } + return sum, nil +} + +var ( + numTable = [256]bool{ + '0': true, + '1': true, + '2': true, + '3': true, + '4': true, + '5': true, + '6': true, + '7': true, + '8': true, + '9': true, + } +) + +var ( + numZeroBuf = []byte{'0'} +) + +func (d *intDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + if len(num) < 2 { + goto ERROR + } + return num, nil + case '0': + s.cursor++ + return numZeroBuf, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + return num, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto ERROR + default: + return nil, d.typeError([]byte{s.char()}, s.totalOffset()) + } + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("number(integer)", s.totalOffset()) +} + +func (d *intDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '0': + cursor++ + return numZeroBuf, cursor, nil + case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for numTable[char(b, cursor)] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, d.typeError([]byte{char(b, cursor)}, cursor) + } + } +} + +func (d *intDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + i64, err := d.parseInt(bytes) + if err != nil { + return d.typeError(bytes, s.totalOffset()) + } + switch d.kind { + case reflect.Int8: + if i64 < -1*(1<<7) || (1<<7) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Int16: + if i64 < -1*(1<<15) || (1<<15) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Int32: + if i64 < -1*(1<<31) || (1<<31) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + } + d.op(p, i64) + s.reset() + return nil +} + +func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + + i64, err := d.parseInt(bytes) + if err != nil { + return 0, d.typeError(bytes, cursor) + } + switch d.kind { + case reflect.Int8: + if i64 < -1*(1<<7) || (1<<7) <= i64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Int16: + if i64 < -1*(1<<15) || (1<<15) <= i64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Int32: + if i64 < -1*(1<<31) || (1<<31) <= i64 { + return 0, d.typeError(bytes, cursor) + } + } + d.op(p, i64) + return cursor, nil +} + +func (d *intDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: int decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go new file mode 100644 index 00000000..45c69ab8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/interface.go @@ -0,0 +1,528 @@ +package decoder + +import ( + "bytes" + "encoding" + "encoding/json" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type interfaceDecoder struct { + typ *runtime.Type + structName string + fieldName string + sliceDecoder *sliceDecoder + mapDecoder *mapDecoder + floatDecoder *floatDecoder + numberDecoder *numberDecoder + stringDecoder *stringDecoder +} + +func newEmptyInterfaceDecoder(structName, fieldName string) *interfaceDecoder { + ifaceDecoder := &interfaceDecoder{ + typ: emptyInterfaceType, + structName: structName, + fieldName: fieldName, + floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*interface{})(p) = v + }), + numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) { + *(*interface{})(p) = v + }), + stringDecoder: newStringDecoder(structName, fieldName), + } + ifaceDecoder.sliceDecoder = newSliceDecoder( + ifaceDecoder, + emptyInterfaceType, + emptyInterfaceType.Size(), + structName, fieldName, + ) + ifaceDecoder.mapDecoder = newMapDecoder( + interfaceMapType, + stringType, + ifaceDecoder.stringDecoder, + interfaceMapType.Elem(), + ifaceDecoder, + structName, + fieldName, + ) + return ifaceDecoder +} + +func newInterfaceDecoder(typ *runtime.Type, structName, fieldName string) *interfaceDecoder { + emptyIfaceDecoder := newEmptyInterfaceDecoder(structName, fieldName) + stringDecoder := newStringDecoder(structName, fieldName) + return &interfaceDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + sliceDecoder: newSliceDecoder( + emptyIfaceDecoder, + emptyInterfaceType, + emptyInterfaceType.Size(), + structName, fieldName, + ), + mapDecoder: newMapDecoder( + interfaceMapType, + stringType, + stringDecoder, + interfaceMapType.Elem(), + emptyIfaceDecoder, + structName, + fieldName, + ), + floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*interface{})(p) = v + }), + numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) { + *(*interface{})(p) = v + }), + stringDecoder: stringDecoder, + } +} + +func (d *interfaceDecoder) numDecoder(s *Stream) Decoder { + if s.UseNumber { + return d.numberDecoder + } + return d.floatDecoder +} + +var ( + emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem()) + EmptyInterfaceType = emptyInterfaceType + interfaceMapType = runtime.Type2RType( + reflect.TypeOf((*map[string]interface{})(nil)).Elem(), + ) + stringType = runtime.Type2RType( + reflect.TypeOf(""), + ) +) + +func decodeStreamUnmarshaler(s *Stream, depth int64, unmarshaler json.Unmarshaler) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(dst); err != nil { + return err + } + return nil +} + +func decodeStreamUnmarshalerContext(s *Stream, depth int64, unmarshaler unmarshalerContext) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(s.Option.Context, dst); err != nil { + return err + } + return nil +} + +func decodeUnmarshaler(buf []byte, cursor, depth int64, unmarshaler json.Unmarshaler) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(dst); err != nil { + return 0, err + } + return end, nil +} + +func decodeUnmarshalerContext(ctx *RuntimeContext, buf []byte, cursor, depth int64, unmarshaler unmarshalerContext) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(ctx.Option.Context, dst); err != nil { + return 0, err + } + return end, nil +} + +func decodeStreamTextUnmarshaler(s *Stream, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return nil + } + + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalText(dst); err != nil { + return err + } + return nil +} + +func decodeTextUnmarshaler(buf []byte, cursor, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + if s, ok := unquoteBytes(src); ok { + src = s + } + if err := unmarshaler.UnmarshalText(src); err != nil { + return 0, err + } + return end, nil +} + +func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p unsafe.Pointer) error { + c := s.skipWhiteSpace() + for { + switch c { + case '{': + var v map[string]interface{} + ptr := unsafe.Pointer(&v) + if err := d.mapDecoder.DecodeStream(s, depth, ptr); err != nil { + return err + } + *(*interface{})(p) = v + return nil + case '[': + var v []interface{} + ptr := unsafe.Pointer(&v) + if err := d.sliceDecoder.DecodeStream(s, depth, ptr); err != nil { + return err + } + *(*interface{})(p) = v + return nil + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.numDecoder(s).DecodeStream(s, depth, p) + case '"': + s.cursor++ + start := s.cursor + for { + switch s.char() { + case '\\': + if _, err := decodeEscapeString(s, nil); err != nil { + return err + } + case '"': + literal := s.buf[start:s.cursor] + s.cursor++ + *(*interface{})(p) = string(literal) + return nil + case nul: + if s.read() { + continue + } + return errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + s.cursor++ + } + case 't': + if err := trueBytes(s); err != nil { + return err + } + **(**interface{})(unsafe.Pointer(&p)) = true + return nil + case 'f': + if err := falseBytes(s); err != nil { + return err + } + **(**interface{})(unsafe.Pointer(&p)) = false + return nil + case 'n': + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + case nul: + if s.read() { + c = s.char() + continue + } + } + break + } + return errors.ErrInvalidBeginningOfValue(c, s.totalOffset()) +} + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + rv := reflect.ValueOf(runtimeInterfaceValue) + if rv.NumMethod() > 0 && rv.CanInterface() { + if u, ok := rv.Interface().(unmarshalerContext); ok { + return decodeStreamUnmarshalerContext(s, depth, u) + } + if u, ok := rv.Interface().(json.Unmarshaler); ok { + return decodeStreamUnmarshaler(s, depth, u) + } + if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok { + return decodeStreamTextUnmarshaler(s, depth, u, p) + } + if s.skipWhiteSpace() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + } + return d.errUnmarshalType(rv.Type(), s.totalOffset()) + } + iface := rv.Interface() + ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface)) + typ := ifaceHeader.typ + if ifaceHeader.ptr == nil || d.typ == typ || typ == nil { + // concrete type is empty interface + return d.decodeStreamEmptyInterface(s, depth, p) + } + if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr { + return d.decodeStreamEmptyInterface(s, depth, p) + } + if s.skipWhiteSpace() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + } + decoder, err := CompileToGetDecoder(typ) + if err != nil { + return err + } + return decoder.DecodeStream(s, depth, ifaceHeader.ptr) +} + +func (d *interfaceDecoder) errUnmarshalType(typ reflect.Type, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: typ.String(), + Type: typ, + Offset: offset, + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *interfaceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + rv := reflect.ValueOf(runtimeInterfaceValue) + if rv.NumMethod() > 0 && rv.CanInterface() { + if u, ok := rv.Interface().(unmarshalerContext); ok { + return decodeUnmarshalerContext(ctx, buf, cursor, depth, u) + } + if u, ok := rv.Interface().(json.Unmarshaler); ok { + return decodeUnmarshaler(buf, cursor, depth, u) + } + if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok { + return decodeTextUnmarshaler(buf, cursor, depth, u, p) + } + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + return 0, d.errUnmarshalType(rv.Type(), cursor) + } + + iface := rv.Interface() + ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface)) + typ := ifaceHeader.typ + if ifaceHeader.ptr == nil || d.typ == typ || typ == nil { + // concrete type is empty interface + return d.decodeEmptyInterface(ctx, cursor, depth, p) + } + if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr { + return d.decodeEmptyInterface(ctx, cursor, depth, p) + } + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + decoder, err := CompileToGetDecoder(typ) + if err != nil { + return 0, err + } + return decoder.Decode(ctx, cursor, depth, ifaceHeader.ptr) +} + +func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case '{': + var v map[string]interface{} + ptr := unsafe.Pointer(&v) + cursor, err := d.mapDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case '[': + var v []interface{} + ptr := unsafe.Pointer(&v) + cursor, err := d.sliceDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.floatDecoder.Decode(ctx, cursor, depth, p) + case '"': + var v string + ptr := unsafe.Pointer(&v) + cursor, err := d.stringDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = true + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + **(**interface{})(unsafe.Pointer(&p)) = false + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) +} + +func NewPathDecoder() Decoder { + ifaceDecoder := &interfaceDecoder{ + typ: emptyInterfaceType, + structName: "", + fieldName: "", + floatDecoder: newFloatDecoder("", "", func(p unsafe.Pointer, v float64) { + *(*interface{})(p) = v + }), + numberDecoder: newNumberDecoder("", "", func(p unsafe.Pointer, v json.Number) { + *(*interface{})(p) = v + }), + stringDecoder: newStringDecoder("", ""), + } + ifaceDecoder.sliceDecoder = newSliceDecoder( + ifaceDecoder, + emptyInterfaceType, + emptyInterfaceType.Size(), + "", "", + ) + ifaceDecoder.mapDecoder = newMapDecoder( + interfaceMapType, + stringType, + ifaceDecoder.stringDecoder, + interfaceMapType.Elem(), + ifaceDecoder, + "", "", + ) + return ifaceDecoder +} + +var ( + truebytes = []byte("true") + falsebytes = []byte("false") +) + +func (d *interfaceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case '{': + return d.mapDecoder.DecodePath(ctx, cursor, depth) + case '[': + return d.sliceDecoder.DecodePath(ctx, cursor, depth) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.floatDecoder.DecodePath(ctx, cursor, depth) + case '"': + return d.stringDecoder.DecodePath(ctx, cursor, depth) + case 't': + if err := validateTrue(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return [][]byte{truebytes}, cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 5 + return [][]byte{falsebytes}, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return [][]byte{nullbytes}, cursor, nil + } + return nil, cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go new file mode 100644 index 00000000..4c9721b0 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go @@ -0,0 +1,55 @@ +package decoder + +import ( + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type invalidDecoder struct { + typ *runtime.Type + kind reflect.Kind + structName string + fieldName string +} + +func newInvalidDecoder(typ *runtime.Type, structName, fieldName string) *invalidDecoder { + return &invalidDecoder{ + typ: typ, + kind: typ.Kind(), + structName: structName, + fieldName: fieldName, + } +} + +func (d *invalidDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + return &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *invalidDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + return 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: cursor, + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *invalidDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: cursor, + Struct: d.structName, + Field: d.fieldName, + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go new file mode 100644 index 00000000..07a9caea --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/map.go @@ -0,0 +1,280 @@ +package decoder + +import ( + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type mapDecoder struct { + mapType *runtime.Type + keyType *runtime.Type + valueType *runtime.Type + canUseAssignFaststrType bool + keyDecoder Decoder + valueDecoder Decoder + structName string + fieldName string +} + +func newMapDecoder(mapType *runtime.Type, keyType *runtime.Type, keyDec Decoder, valueType *runtime.Type, valueDec Decoder, structName, fieldName string) *mapDecoder { + return &mapDecoder{ + mapType: mapType, + keyDecoder: keyDec, + keyType: keyType, + canUseAssignFaststrType: canUseAssignFaststrType(keyType, valueType), + valueType: valueType, + valueDecoder: valueDec, + structName: structName, + fieldName: fieldName, + } +} + +const ( + mapMaxElemSize = 128 +) + +// See detail: https://github.com/goccy/go-json/pull/283 +func canUseAssignFaststrType(key *runtime.Type, value *runtime.Type) bool { + indirectElem := value.Size() > mapMaxElemSize + if indirectElem { + return false + } + return key.Kind() == reflect.String +} + +//go:linkname makemap reflect.makemap +func makemap(*runtime.Type, int) unsafe.Pointer + +//nolint:golint +//go:linkname mapassign_faststr runtime.mapassign_faststr +//go:noescape +func mapassign_faststr(t *runtime.Type, m unsafe.Pointer, s string) unsafe.Pointer + +//go:linkname mapassign reflect.mapassign +//go:noescape +func mapassign(t *runtime.Type, m unsafe.Pointer, k, v unsafe.Pointer) + +func (d *mapDecoder) mapassign(t *runtime.Type, m, k, v unsafe.Pointer) { + if d.canUseAssignFaststrType { + mapV := mapassign_faststr(t, m, *(*string)(k)) + typedmemmove(d.valueType, mapV, v) + } else { + mapassign(t, m, k, v) + } +} + +func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + switch s.skipWhiteSpace() { + case 'n': + if err := nullBytes(s); err != nil { + return err + } + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil + return nil + case '{': + default: + return errors.ErrExpected("{ character for map value", s.totalOffset()) + } + mapValue := *(*unsafe.Pointer)(p) + if mapValue == nil { + mapValue = makemap(d.mapType, 0) + } + s.cursor++ + if s.skipWhiteSpace() == '}' { + *(*unsafe.Pointer)(p) = mapValue + s.cursor++ + return nil + } + for { + k := unsafe_New(d.keyType) + if err := d.keyDecoder.DecodeStream(s, depth, k); err != nil { + return err + } + s.skipWhiteSpace() + if !s.equalChar(':') { + return errors.ErrExpected("colon after object key", s.totalOffset()) + } + s.cursor++ + v := unsafe_New(d.valueType) + if err := d.valueDecoder.DecodeStream(s, depth, v); err != nil { + return err + } + d.mapassign(d.mapType, mapValue, k, v) + s.skipWhiteSpace() + if s.equalChar('}') { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + s.cursor++ + return nil + } + if !s.equalChar(',') { + return errors.ErrExpected("comma after object value", s.totalOffset()) + } + s.cursor++ + } +} + +func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + cursor = skipWhiteSpace(buf, cursor) + buflen := int64(len(buf)) + if buflen < 2 { + return 0, errors.ErrExpected("{} for map", cursor) + } + switch buf[cursor] { + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil + return cursor, nil + case '{': + default: + return 0, errors.ErrExpected("{ character for map value", cursor) + } + cursor++ + cursor = skipWhiteSpace(buf, cursor) + mapValue := *(*unsafe.Pointer)(p) + if mapValue == nil { + mapValue = makemap(d.mapType, 0) + } + if buf[cursor] == '}' { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + cursor++ + return cursor, nil + } + for { + k := unsafe_New(d.keyType) + keyCursor, err := d.keyDecoder.Decode(ctx, cursor, depth, k) + if err != nil { + return 0, err + } + cursor = skipWhiteSpace(buf, keyCursor) + if buf[cursor] != ':' { + return 0, errors.ErrExpected("colon after object key", cursor) + } + cursor++ + v := unsafe_New(d.valueType) + valueCursor, err := d.valueDecoder.Decode(ctx, cursor, depth, v) + if err != nil { + return 0, err + } + d.mapassign(d.mapType, mapValue, k, v) + cursor = skipWhiteSpace(buf, valueCursor) + if buf[cursor] == '}' { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + cursor++ + return cursor, nil + } + if buf[cursor] != ',' { + return 0, errors.ErrExpected("comma after object value", cursor) + } + cursor++ + } +} + +func (d *mapDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + cursor = skipWhiteSpace(buf, cursor) + buflen := int64(len(buf)) + if buflen < 2 { + return nil, 0, errors.ErrExpected("{} for map", cursor) + } + switch buf[cursor] { + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return [][]byte{nullbytes}, cursor, nil + case '{': + default: + return nil, 0, errors.ErrExpected("{ character for map value", cursor) + } + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '}' { + cursor++ + return nil, cursor, nil + } + keyDecoder, ok := d.keyDecoder.(*stringDecoder) + if !ok { + return nil, 0, &errors.UnmarshalTypeError{ + Value: "string", + Type: reflect.TypeOf(""), + Offset: cursor, + Struct: d.structName, + Field: d.fieldName, + } + } + ret := [][]byte{} + for { + key, keyCursor, err := keyDecoder.decodeByte(buf, cursor) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(buf, keyCursor) + if buf[cursor] != ':' { + return nil, 0, errors.ErrExpected("colon after object key", cursor) + } + cursor++ + child, found, err := ctx.Option.Path.Field(string(key)) + if err != nil { + return nil, 0, err + } + if found { + if child != nil { + oldPath := ctx.Option.Path.node + ctx.Option.Path.node = child + paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth) + if err != nil { + return nil, 0, err + } + ctx.Option.Path.node = oldPath + ret = append(ret, paths...) + cursor = c + } else { + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return nil, 0, err + } + ret = append(ret, buf[start:end]) + cursor = end + } + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return nil, 0, err + } + cursor = c + } + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '}' { + cursor++ + return ret, cursor, nil + } + if buf[cursor] != ',' { + return nil, 0, errors.ErrExpected("comma after object value", cursor) + } + cursor++ + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go new file mode 100644 index 00000000..10e5435e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/number.go @@ -0,0 +1,123 @@ +package decoder + +import ( + "encoding/json" + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type numberDecoder struct { + stringDecoder *stringDecoder + op func(unsafe.Pointer, json.Number) + structName string + fieldName string +} + +func newNumberDecoder(structName, fieldName string, op func(unsafe.Pointer, json.Number)) *numberDecoder { + return &numberDecoder{ + stringDecoder: newStringDecoder(structName, fieldName), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *numberDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil { + return errors.ErrSyntax(err.Error(), s.totalOffset()) + } + d.op(p, json.Number(string(bytes))) + s.reset() + return nil +} + +func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil { + return 0, errors.ErrSyntax(err.Error(), c) + } + cursor = c + s := *(*string)(unsafe.Pointer(&bytes)) + d.op(p, json.Number(s)) + return cursor, nil +} + +func (d *numberDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return nil, 0, err + } + if bytes == nil { + return [][]byte{nullbytes}, c, nil + } + return [][]byte{bytes}, c, nil +} + +func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + start := s.cursor + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return floatBytes(s), nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case '"': + return d.stringDecoder.decodeStreamByte(s) + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + if s.cursor == start { + return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) + } + return nil, errors.ErrUnexpectedEndOfJSON("json.Number", s.totalOffset()) +} + +func (d *numberDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for floatTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + case '"': + return d.stringDecoder.decodeByte(buf, cursor) + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("json.Number", cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go new file mode 100644 index 00000000..502f772e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/option.go @@ -0,0 +1,17 @@ +package decoder + +import "context" + +type OptionFlags uint8 + +const ( + FirstWinOption OptionFlags = 1 << iota + ContextOption + PathOption +) + +type Option struct { + Flags OptionFlags + Context context.Context + Path *Path +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/path.go b/vendor/github.com/goccy/go-json/internal/decoder/path.go new file mode 100644 index 00000000..a15ff69e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/path.go @@ -0,0 +1,670 @@ +package decoder + +import ( + "fmt" + "reflect" + "strconv" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type PathString string + +func (s PathString) Build() (*Path, error) { + builder := new(PathBuilder) + return builder.Build([]rune(s)) +} + +type PathBuilder struct { + root PathNode + node PathNode + singleQuotePathSelector bool + doubleQuotePathSelector bool +} + +func (b *PathBuilder) Build(buf []rune) (*Path, error) { + node, err := b.build(buf) + if err != nil { + return nil, err + } + return &Path{ + node: node, + RootSelectorOnly: node == nil, + SingleQuotePathSelector: b.singleQuotePathSelector, + DoubleQuotePathSelector: b.doubleQuotePathSelector, + }, nil +} + +func (b *PathBuilder) build(buf []rune) (PathNode, error) { + if len(buf) == 0 { + return nil, errors.ErrEmptyPath() + } + if buf[0] != '$' { + return nil, errors.ErrInvalidPath("JSON Path must start with a $ character") + } + if len(buf) == 1 { + return nil, nil + } + buf = buf[1:] + offset, err := b.buildNext(buf) + if err != nil { + return nil, err + } + if len(buf) > offset { + return nil, errors.ErrInvalidPath("remain invalid path %q", buf[offset:]) + } + return b.root, nil +} + +func (b *PathBuilder) buildNextCharIfExists(buf []rune, cursor int) (int, error) { + if len(buf) > cursor { + offset, err := b.buildNext(buf[cursor:]) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + } + return cursor, nil +} + +func (b *PathBuilder) buildNext(buf []rune) (int, error) { + switch buf[0] { + case '.': + if len(buf) == 1 { + return 0, errors.ErrInvalidPath("JSON Path ends with dot character") + } + offset, err := b.buildSelector(buf[1:]) + if err != nil { + return 0, err + } + return offset + 1, nil + case '[': + if len(buf) == 1 { + return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character") + } + offset, err := b.buildIndex(buf[1:]) + if err != nil { + return 0, err + } + return offset + 1, nil + default: + return 0, errors.ErrInvalidPath("expect dot or left bracket character. but found %c character", buf[0]) + } +} + +func (b *PathBuilder) buildSelector(buf []rune) (int, error) { + switch buf[0] { + case '.': + if len(buf) == 1 { + return 0, errors.ErrInvalidPath("JSON Path ends with double dot character") + } + offset, err := b.buildPathRecursive(buf[1:]) + if err != nil { + return 0, err + } + return 1 + offset, nil + case '[', ']', '$', '*': + return 0, errors.ErrInvalidPath("found invalid path character %c after dot", buf[0]) + } + for cursor := 0; cursor < len(buf); cursor++ { + switch buf[cursor] { + case '$', '*', ']': + return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor]) + case '.': + if cursor+1 >= len(buf) { + return 0, errors.ErrInvalidPath("JSON Path ends with dot character") + } + selector := buf[:cursor] + b.addSelectorNode(string(selector)) + offset, err := b.buildSelector(buf[cursor+1:]) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + case '[': + if cursor+1 >= len(buf) { + return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character") + } + selector := buf[:cursor] + b.addSelectorNode(string(selector)) + offset, err := b.buildIndex(buf[cursor+1:]) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + case '"': + if cursor+1 >= len(buf) { + return 0, errors.ErrInvalidPath("JSON Path ends with double quote character") + } + offset, err := b.buildQuoteSelector(buf[cursor+1:], DoubleQuotePathSelector) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + } + } + b.addSelectorNode(string(buf)) + return len(buf), nil +} + +func (b *PathBuilder) buildQuoteSelector(buf []rune, sel QuotePathSelector) (int, error) { + switch buf[0] { + case '[', ']', '$', '.', '*', '\'', '"': + return 0, errors.ErrInvalidPath("found invalid path character %c after quote", buf[0]) + } + for cursor := 0; cursor < len(buf); cursor++ { + switch buf[cursor] { + case '\'': + if sel != SingleQuotePathSelector { + return 0, errors.ErrInvalidPath("found double quote character in field selector with single quote context") + } + if len(buf) <= cursor+1 { + return 0, errors.ErrInvalidPath("JSON Path ends with single quote character in field selector context") + } + if buf[cursor+1] != ']' { + return 0, errors.ErrInvalidPath("expect right bracket for field selector with single quote but found %c", buf[cursor+1]) + } + selector := buf[:cursor] + b.addSelectorNode(string(selector)) + b.singleQuotePathSelector = true + return b.buildNextCharIfExists(buf, cursor+2) + case '"': + if sel != DoubleQuotePathSelector { + return 0, errors.ErrInvalidPath("found single quote character in field selector with double quote context") + } + selector := buf[:cursor] + b.addSelectorNode(string(selector)) + b.doubleQuotePathSelector = true + return b.buildNextCharIfExists(buf, cursor+1) + } + } + return 0, errors.ErrInvalidPath("couldn't find quote character in selector quote path context") +} + +func (b *PathBuilder) buildPathRecursive(buf []rune) (int, error) { + switch buf[0] { + case '.', '[', ']', '$', '*': + return 0, errors.ErrInvalidPath("found invalid path character %c after double dot", buf[0]) + } + for cursor := 0; cursor < len(buf); cursor++ { + switch buf[cursor] { + case '$', '*', ']': + return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor]) + case '.': + if cursor+1 >= len(buf) { + return 0, errors.ErrInvalidPath("JSON Path ends with dot character") + } + selector := buf[:cursor] + b.addRecursiveNode(string(selector)) + offset, err := b.buildSelector(buf[cursor+1:]) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + case '[': + if cursor+1 >= len(buf) { + return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character") + } + selector := buf[:cursor] + b.addRecursiveNode(string(selector)) + offset, err := b.buildIndex(buf[cursor+1:]) + if err != nil { + return 0, err + } + return cursor + 1 + offset, nil + } + } + b.addRecursiveNode(string(buf)) + return len(buf), nil +} + +func (b *PathBuilder) buildIndex(buf []rune) (int, error) { + switch buf[0] { + case '.', '[', ']', '$': + return 0, errors.ErrInvalidPath("found invalid path character %c after left bracket", buf[0]) + case '\'': + if len(buf) == 1 { + return 0, errors.ErrInvalidPath("JSON Path ends with single quote character") + } + offset, err := b.buildQuoteSelector(buf[1:], SingleQuotePathSelector) + if err != nil { + return 0, err + } + return 1 + offset, nil + case '*': + if len(buf) == 1 { + return 0, errors.ErrInvalidPath("JSON Path ends with star character") + } + if buf[1] != ']' { + return 0, errors.ErrInvalidPath("expect right bracket character for index all path but found %c character", buf[1]) + } + b.addIndexAllNode() + offset := len("*]") + if len(buf) > 2 { + buildOffset, err := b.buildNext(buf[2:]) + if err != nil { + return 0, err + } + return offset + buildOffset, nil + } + return offset, nil + } + + for cursor := 0; cursor < len(buf); cursor++ { + switch buf[cursor] { + case ']': + index, err := strconv.ParseInt(string(buf[:cursor]), 10, 64) + if err != nil { + return 0, errors.ErrInvalidPath("%q is unexpected index path", buf[:cursor]) + } + b.addIndexNode(int(index)) + return b.buildNextCharIfExists(buf, cursor+1) + } + } + return 0, errors.ErrInvalidPath("couldn't find right bracket character in index path context") +} + +func (b *PathBuilder) addIndexAllNode() { + node := newPathIndexAllNode() + if b.root == nil { + b.root = node + b.node = node + } else { + b.node = b.node.chain(node) + } +} + +func (b *PathBuilder) addRecursiveNode(selector string) { + node := newPathRecursiveNode(selector) + if b.root == nil { + b.root = node + b.node = node + } else { + b.node = b.node.chain(node) + } +} + +func (b *PathBuilder) addSelectorNode(name string) { + node := newPathSelectorNode(name) + if b.root == nil { + b.root = node + b.node = node + } else { + b.node = b.node.chain(node) + } +} + +func (b *PathBuilder) addIndexNode(idx int) { + node := newPathIndexNode(idx) + if b.root == nil { + b.root = node + b.node = node + } else { + b.node = b.node.chain(node) + } +} + +type QuotePathSelector int + +const ( + SingleQuotePathSelector QuotePathSelector = 1 + DoubleQuotePathSelector QuotePathSelector = 2 +) + +type Path struct { + node PathNode + RootSelectorOnly bool + SingleQuotePathSelector bool + DoubleQuotePathSelector bool +} + +func (p *Path) Field(sel string) (PathNode, bool, error) { + if p.node == nil { + return nil, false, nil + } + return p.node.Field(sel) +} + +func (p *Path) Get(src, dst reflect.Value) error { + if p.node == nil { + return nil + } + return p.node.Get(src, dst) +} + +func (p *Path) String() string { + if p.node == nil { + return "$" + } + return p.node.String() +} + +type PathNode interface { + fmt.Stringer + Index(idx int) (PathNode, bool, error) + Field(fieldName string) (PathNode, bool, error) + Get(src, dst reflect.Value) error + chain(PathNode) PathNode + target() bool + single() bool +} + +type BasePathNode struct { + child PathNode +} + +func (n *BasePathNode) chain(node PathNode) PathNode { + n.child = node + return node +} + +func (n *BasePathNode) target() bool { + return n.child == nil +} + +func (n *BasePathNode) single() bool { + return true +} + +type PathSelectorNode struct { + *BasePathNode + selector string +} + +func newPathSelectorNode(selector string) *PathSelectorNode { + return &PathSelectorNode{ + BasePathNode: &BasePathNode{}, + selector: selector, + } +} + +func (n *PathSelectorNode) Index(idx int) (PathNode, bool, error) { + return nil, false, &errors.PathError{} +} + +func (n *PathSelectorNode) Field(fieldName string) (PathNode, bool, error) { + if n.selector == fieldName { + return n.child, true, nil + } + return nil, false, nil +} + +func (n *PathSelectorNode) Get(src, dst reflect.Value) error { + switch src.Type().Kind() { + case reflect.Map: + iter := src.MapRange() + for iter.Next() { + key, ok := iter.Key().Interface().(string) + if !ok { + return fmt.Errorf("invalid map key type %T", src.Type().Key()) + } + child, found, err := n.Field(key) + if err != nil { + return err + } + if found { + if child != nil { + return child.Get(iter.Value(), dst) + } + return AssignValue(iter.Value(), dst) + } + } + case reflect.Struct: + typ := src.Type() + for i := 0; i < typ.Len(); i++ { + tag := runtime.StructTagFromField(typ.Field(i)) + child, found, err := n.Field(tag.Key) + if err != nil { + return err + } + if found { + if child != nil { + return child.Get(src.Field(i), dst) + } + return AssignValue(src.Field(i), dst) + } + } + case reflect.Ptr: + return n.Get(src.Elem(), dst) + case reflect.Interface: + return n.Get(reflect.ValueOf(src.Interface()), dst) + case reflect.Float64, reflect.String, reflect.Bool: + return AssignValue(src, dst) + } + return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type()) +} + +func (n *PathSelectorNode) String() string { + s := fmt.Sprintf(".%s", n.selector) + if n.child != nil { + s += n.child.String() + } + return s +} + +type PathIndexNode struct { + *BasePathNode + selector int +} + +func newPathIndexNode(selector int) *PathIndexNode { + return &PathIndexNode{ + BasePathNode: &BasePathNode{}, + selector: selector, + } +} + +func (n *PathIndexNode) Index(idx int) (PathNode, bool, error) { + if n.selector == idx { + return n.child, true, nil + } + return nil, false, nil +} + +func (n *PathIndexNode) Field(fieldName string) (PathNode, bool, error) { + return nil, false, &errors.PathError{} +} + +func (n *PathIndexNode) Get(src, dst reflect.Value) error { + switch src.Type().Kind() { + case reflect.Array, reflect.Slice: + if src.Len() > n.selector { + if n.child != nil { + return n.child.Get(src.Index(n.selector), dst) + } + return AssignValue(src.Index(n.selector), dst) + } + case reflect.Ptr: + return n.Get(src.Elem(), dst) + case reflect.Interface: + return n.Get(reflect.ValueOf(src.Interface()), dst) + } + return fmt.Errorf("failed to get [%d] value from %s", n.selector, src.Type()) +} + +func (n *PathIndexNode) String() string { + s := fmt.Sprintf("[%d]", n.selector) + if n.child != nil { + s += n.child.String() + } + return s +} + +type PathIndexAllNode struct { + *BasePathNode +} + +func newPathIndexAllNode() *PathIndexAllNode { + return &PathIndexAllNode{ + BasePathNode: &BasePathNode{}, + } +} + +func (n *PathIndexAllNode) Index(idx int) (PathNode, bool, error) { + return n.child, true, nil +} + +func (n *PathIndexAllNode) Field(fieldName string) (PathNode, bool, error) { + return nil, false, &errors.PathError{} +} + +func (n *PathIndexAllNode) Get(src, dst reflect.Value) error { + switch src.Type().Kind() { + case reflect.Array, reflect.Slice: + var arr []interface{} + for i := 0; i < src.Len(); i++ { + var v interface{} + rv := reflect.ValueOf(&v) + if n.child != nil { + if err := n.child.Get(src.Index(i), rv); err != nil { + return err + } + } else { + if err := AssignValue(src.Index(i), rv); err != nil { + return err + } + } + arr = append(arr, v) + } + if err := AssignValue(reflect.ValueOf(arr), dst); err != nil { + return err + } + return nil + case reflect.Ptr: + return n.Get(src.Elem(), dst) + case reflect.Interface: + return n.Get(reflect.ValueOf(src.Interface()), dst) + } + return fmt.Errorf("failed to get all value from %s", src.Type()) +} + +func (n *PathIndexAllNode) String() string { + s := "[*]" + if n.child != nil { + s += n.child.String() + } + return s +} + +type PathRecursiveNode struct { + *BasePathNode + selector string +} + +func newPathRecursiveNode(selector string) *PathRecursiveNode { + node := newPathSelectorNode(selector) + return &PathRecursiveNode{ + BasePathNode: &BasePathNode{ + child: node, + }, + selector: selector, + } +} + +func (n *PathRecursiveNode) Field(fieldName string) (PathNode, bool, error) { + if n.selector == fieldName { + return n.child, true, nil + } + return nil, false, nil +} + +func (n *PathRecursiveNode) Index(_ int) (PathNode, bool, error) { + return n, true, nil +} + +func valueToSliceValue(v interface{}) []interface{} { + rv := reflect.ValueOf(v) + ret := []interface{}{} + if rv.Type().Kind() == reflect.Slice || rv.Type().Kind() == reflect.Array { + for i := 0; i < rv.Len(); i++ { + ret = append(ret, rv.Index(i).Interface()) + } + return ret + } + return []interface{}{v} +} + +func (n *PathRecursiveNode) Get(src, dst reflect.Value) error { + if n.child == nil { + return fmt.Errorf("failed to get by recursive path ..%s", n.selector) + } + var arr []interface{} + switch src.Type().Kind() { + case reflect.Map: + iter := src.MapRange() + for iter.Next() { + key, ok := iter.Key().Interface().(string) + if !ok { + return fmt.Errorf("invalid map key type %T", src.Type().Key()) + } + child, found, err := n.Field(key) + if err != nil { + return err + } + if found { + var v interface{} + rv := reflect.ValueOf(&v) + _ = child.Get(iter.Value(), rv) + arr = append(arr, valueToSliceValue(v)...) + } else { + var v interface{} + rv := reflect.ValueOf(&v) + _ = n.Get(iter.Value(), rv) + if v != nil { + arr = append(arr, valueToSliceValue(v)...) + } + } + } + _ = AssignValue(reflect.ValueOf(arr), dst) + return nil + case reflect.Struct: + typ := src.Type() + for i := 0; i < typ.Len(); i++ { + tag := runtime.StructTagFromField(typ.Field(i)) + child, found, err := n.Field(tag.Key) + if err != nil { + return err + } + if found { + var v interface{} + rv := reflect.ValueOf(&v) + _ = child.Get(src.Field(i), rv) + arr = append(arr, valueToSliceValue(v)...) + } else { + var v interface{} + rv := reflect.ValueOf(&v) + _ = n.Get(src.Field(i), rv) + if v != nil { + arr = append(arr, valueToSliceValue(v)...) + } + } + } + _ = AssignValue(reflect.ValueOf(arr), dst) + return nil + case reflect.Array, reflect.Slice: + for i := 0; i < src.Len(); i++ { + var v interface{} + rv := reflect.ValueOf(&v) + _ = n.Get(src.Index(i), rv) + if v != nil { + arr = append(arr, valueToSliceValue(v)...) + } + } + _ = AssignValue(reflect.ValueOf(arr), dst) + return nil + case reflect.Ptr: + return n.Get(src.Elem(), dst) + case reflect.Interface: + return n.Get(reflect.ValueOf(src.Interface()), dst) + } + return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type()) +} + +func (n *PathRecursiveNode) String() string { + s := fmt.Sprintf("..%s", n.selector) + if n.child != nil { + s += n.child.String() + } + return s +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go new file mode 100644 index 00000000..ae229946 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go @@ -0,0 +1,97 @@ +package decoder + +import ( + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type ptrDecoder struct { + dec Decoder + typ *runtime.Type + structName string + fieldName string +} + +func newPtrDecoder(dec Decoder, typ *runtime.Type, structName, fieldName string) *ptrDecoder { + return &ptrDecoder{ + dec: dec, + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *ptrDecoder) contentDecoder() Decoder { + dec, ok := d.dec.(*ptrDecoder) + if !ok { + return d.dec + } + return dec.contentDecoder() +} + +//nolint:golint +//go:linkname unsafe_New reflect.unsafe_New +func unsafe_New(*runtime.Type) unsafe.Pointer + +func UnsafeNew(t *runtime.Type) unsafe.Pointer { + return unsafe_New(t) +} + +func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + if s.skipWhiteSpace() == nul { + s.read() + } + if s.char() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*unsafe.Pointer)(p) = nil + return nil + } + var newptr unsafe.Pointer + if *(*unsafe.Pointer)(p) == nil { + newptr = unsafe_New(d.typ) + *(*unsafe.Pointer)(p) = newptr + } else { + newptr = *(*unsafe.Pointer)(p) + } + if err := d.dec.DecodeStream(s, depth, newptr); err != nil { + return err + } + return nil +} + +func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + if p != nil { + *(*unsafe.Pointer)(p) = nil + } + cursor += 4 + return cursor, nil + } + var newptr unsafe.Pointer + if *(*unsafe.Pointer)(p) == nil { + newptr = unsafe_New(d.typ) + *(*unsafe.Pointer)(p) = newptr + } else { + newptr = *(*unsafe.Pointer)(p) + } + c, err := d.dec.Decode(ctx, cursor, depth, newptr) + if err != nil { + *(*unsafe.Pointer)(p) = nil + return 0, err + } + cursor = c + return cursor, nil +} + +func (d *ptrDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: ptr decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go new file mode 100644 index 00000000..30a23e4b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/slice.go @@ -0,0 +1,380 @@ +package decoder + +import ( + "reflect" + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +var ( + sliceType = runtime.Type2RType( + reflect.TypeOf((*sliceHeader)(nil)).Elem(), + ) + nilSlice = unsafe.Pointer(&sliceHeader{}) +) + +type sliceDecoder struct { + elemType *runtime.Type + isElemPointerType bool + valueDecoder Decoder + size uintptr + arrayPool sync.Pool + structName string + fieldName string +} + +// If use reflect.SliceHeader, data type is uintptr. +// In this case, Go compiler cannot trace reference created by newArray(). +// So, define using unsafe.Pointer as data type +type sliceHeader struct { + data unsafe.Pointer + len int + cap int +} + +const ( + defaultSliceCapacity = 2 +) + +func newSliceDecoder(dec Decoder, elemType *runtime.Type, size uintptr, structName, fieldName string) *sliceDecoder { + return &sliceDecoder{ + valueDecoder: dec, + elemType: elemType, + isElemPointerType: elemType.Kind() == reflect.Ptr || elemType.Kind() == reflect.Map, + size: size, + arrayPool: sync.Pool{ + New: func() interface{} { + return &sliceHeader{ + data: newArray(elemType, defaultSliceCapacity), + len: 0, + cap: defaultSliceCapacity, + } + }, + }, + structName: structName, + fieldName: fieldName, + } +} + +func (d *sliceDecoder) newSlice(src *sliceHeader) *sliceHeader { + slice := d.arrayPool.Get().(*sliceHeader) + if src.len > 0 { + // copy original elem + if slice.cap < src.cap { + data := newArray(d.elemType, src.cap) + slice = &sliceHeader{data: data, len: src.len, cap: src.cap} + } else { + slice.len = src.len + } + copySlice(d.elemType, *slice, *src) + } else { + slice.len = 0 + } + return slice +} + +func (d *sliceDecoder) releaseSlice(p *sliceHeader) { + d.arrayPool.Put(p) +} + +//go:linkname copySlice reflect.typedslicecopy +func copySlice(elemType *runtime.Type, dst, src sliceHeader) int + +//go:linkname newArray reflect.unsafe_NewArray +func newArray(*runtime.Type, int) unsafe.Pointer + +//go:linkname typedmemmove reflect.typedmemmove +func typedmemmove(t *runtime.Type, dst, src unsafe.Pointer) + +func (d *sliceDecoder) errNumber(offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: "number", + Type: reflect.SliceOf(runtime.RType2Type(d.elemType)), + Struct: d.structName, + Field: d.fieldName, + Offset: offset, + } +} + +func (d *sliceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case 'n': + if err := nullBytes(s); err != nil { + return err + } + typedmemmove(sliceType, p, nilSlice) + return nil + case '[': + s.cursor++ + if s.skipWhiteSpace() == ']' { + dst := (*sliceHeader)(p) + if dst.data == nil { + dst.data = newArray(d.elemType, 0) + } else { + dst.len = 0 + } + s.cursor++ + return nil + } + idx := 0 + slice := d.newSlice((*sliceHeader)(p)) + srcLen := slice.len + capacity := slice.cap + data := slice.data + for { + if capacity <= idx { + src := sliceHeader{data: data, len: idx, cap: capacity} + capacity *= 2 + data = newArray(d.elemType, capacity) + dst := sliceHeader{data: data, len: idx, cap: capacity} + copySlice(d.elemType, dst, src) + } + ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size) + + // if srcLen is greater than idx, keep the original reference + if srcLen <= idx { + if d.isElemPointerType { + **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer + } else { + // assign new element to the slice + typedmemmove(d.elemType, ep, unsafe_New(d.elemType)) + } + } + + if err := d.valueDecoder.DecodeStream(s, depth, ep); err != nil { + return err + } + s.skipWhiteSpace() + RETRY: + switch s.char() { + case ']': + slice.cap = capacity + slice.len = idx + 1 + slice.data = data + dst := (*sliceHeader)(p) + dst.len = idx + 1 + if dst.len > dst.cap { + dst.data = newArray(d.elemType, dst.len) + dst.cap = dst.len + } + copySlice(d.elemType, *dst, *slice) + d.releaseSlice(slice) + s.cursor++ + return nil + case ',': + idx++ + case nul: + if s.read() { + goto RETRY + } + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + goto ERROR + default: + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + goto ERROR + } + s.cursor++ + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.errNumber(s.totalOffset()) + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("slice", s.totalOffset()) +} + +func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + typedmemmove(sliceType, p, nilSlice) + return cursor, nil + case '[': + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == ']' { + dst := (*sliceHeader)(p) + if dst.data == nil { + dst.data = newArray(d.elemType, 0) + } else { + dst.len = 0 + } + cursor++ + return cursor, nil + } + idx := 0 + slice := d.newSlice((*sliceHeader)(p)) + srcLen := slice.len + capacity := slice.cap + data := slice.data + for { + if capacity <= idx { + src := sliceHeader{data: data, len: idx, cap: capacity} + capacity *= 2 + data = newArray(d.elemType, capacity) + dst := sliceHeader{data: data, len: idx, cap: capacity} + copySlice(d.elemType, dst, src) + } + ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size) + // if srcLen is greater than idx, keep the original reference + if srcLen <= idx { + if d.isElemPointerType { + **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer + } else { + // assign new element to the slice + typedmemmove(d.elemType, ep, unsafe_New(d.elemType)) + } + } + c, err := d.valueDecoder.Decode(ctx, cursor, depth, ep) + if err != nil { + return 0, err + } + cursor = c + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case ']': + slice.cap = capacity + slice.len = idx + 1 + slice.data = data + dst := (*sliceHeader)(p) + dst.len = idx + 1 + if dst.len > dst.cap { + dst.data = newArray(d.elemType, dst.len) + dst.cap = dst.len + } + copySlice(d.elemType, *dst, *slice) + d.releaseSlice(slice) + cursor++ + return cursor, nil + case ',': + idx++ + default: + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + return 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor) + } + cursor++ + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, d.errNumber(cursor) + default: + return 0, errors.ErrUnexpectedEndOfJSON("slice", cursor) + } + } +} + +func (d *sliceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + ret := [][]byte{} + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return [][]byte{nullbytes}, cursor, nil + case '[': + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == ']' { + cursor++ + return ret, cursor, nil + } + idx := 0 + for { + child, found, err := ctx.Option.Path.node.Index(idx) + if err != nil { + return nil, 0, err + } + if found { + if child != nil { + oldPath := ctx.Option.Path.node + ctx.Option.Path.node = child + paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth) + if err != nil { + return nil, 0, err + } + ctx.Option.Path.node = oldPath + ret = append(ret, paths...) + cursor = c + } else { + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return nil, 0, err + } + ret = append(ret, buf[start:end]) + cursor = end + } + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return nil, 0, err + } + cursor = c + } + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case ']': + cursor++ + return ret, cursor, nil + case ',': + idx++ + default: + return nil, 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor) + } + cursor++ + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return nil, 0, d.errNumber(cursor) + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("slice", cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/stream.go b/vendor/github.com/goccy/go-json/internal/decoder/stream.go new file mode 100644 index 00000000..a383f725 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/stream.go @@ -0,0 +1,556 @@ +package decoder + +import ( + "bytes" + "encoding/json" + "io" + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +const ( + initBufSize = 512 +) + +type Stream struct { + buf []byte + bufSize int64 + length int64 + r io.Reader + offset int64 + cursor int64 + filledBuffer bool + allRead bool + UseNumber bool + DisallowUnknownFields bool + Option *Option +} + +func NewStream(r io.Reader) *Stream { + return &Stream{ + r: r, + bufSize: initBufSize, + buf: make([]byte, initBufSize), + Option: &Option{}, + } +} + +func (s *Stream) TotalOffset() int64 { + return s.totalOffset() +} + +func (s *Stream) Buffered() io.Reader { + buflen := int64(len(s.buf)) + for i := s.cursor; i < buflen; i++ { + if s.buf[i] == nul { + return bytes.NewReader(s.buf[s.cursor:i]) + } + } + return bytes.NewReader(s.buf[s.cursor:]) +} + +func (s *Stream) PrepareForDecode() error { + for { + switch s.char() { + case ' ', '\t', '\r', '\n': + s.cursor++ + continue + case ',', ':': + s.cursor++ + return nil + case nul: + if s.read() { + continue + } + return io.EOF + } + break + } + return nil +} + +func (s *Stream) totalOffset() int64 { + return s.offset + s.cursor +} + +func (s *Stream) char() byte { + return s.buf[s.cursor] +} + +func (s *Stream) equalChar(c byte) bool { + cur := s.buf[s.cursor] + if cur == nul { + s.read() + cur = s.buf[s.cursor] + } + return cur == c +} + +func (s *Stream) stat() ([]byte, int64, unsafe.Pointer) { + return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) bufptr() unsafe.Pointer { + return (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) { + s.cursor-- // for retry ( because caller progress cursor position in each loop ) + return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) Reset() { + s.reset() + s.bufSize = int64(len(s.buf)) +} + +func (s *Stream) More() bool { + for { + switch s.char() { + case ' ', '\n', '\r', '\t': + s.cursor++ + continue + case '}', ']': + return false + case nul: + if s.read() { + continue + } + return false + } + break + } + return true +} + +func (s *Stream) Token() (interface{}, error) { + for { + c := s.char() + switch c { + case ' ', '\n', '\r', '\t': + s.cursor++ + case '{', '[', ']', '}': + s.cursor++ + return json.Delim(c), nil + case ',', ':': + s.cursor++ + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + bytes := floatBytes(s) + str := *(*string)(unsafe.Pointer(&bytes)) + if s.UseNumber { + return json.Number(str), nil + } + f64, err := strconv.ParseFloat(str, 64) + if err != nil { + return nil, err + } + return f64, nil + case '"': + bytes, err := stringBytes(s) + if err != nil { + return nil, err + } + return string(bytes), nil + case 't': + if err := trueBytes(s); err != nil { + return nil, err + } + return true, nil + case 'f': + if err := falseBytes(s); err != nil { + return nil, err + } + return false, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto END + default: + return nil, errors.ErrInvalidCharacter(s.char(), "token", s.totalOffset()) + } + } +END: + return nil, io.EOF +} + +func (s *Stream) reset() { + s.offset += s.cursor + s.buf = s.buf[s.cursor:] + s.length -= s.cursor + s.cursor = 0 +} + +func (s *Stream) readBuf() []byte { + if s.filledBuffer { + s.bufSize *= 2 + remainBuf := s.buf + s.buf = make([]byte, s.bufSize) + copy(s.buf, remainBuf) + } + remainLen := s.length - s.cursor + remainNotNulCharNum := int64(0) + for i := int64(0); i < remainLen; i++ { + if s.buf[s.cursor+i] == nul { + break + } + remainNotNulCharNum++ + } + s.length = s.cursor + remainNotNulCharNum + return s.buf[s.cursor+remainNotNulCharNum:] +} + +func (s *Stream) read() bool { + if s.allRead { + return false + } + buf := s.readBuf() + last := len(buf) - 1 + buf[last] = nul + n, err := s.r.Read(buf[:last]) + s.length += int64(n) + if n == last { + s.filledBuffer = true + } else { + s.filledBuffer = false + } + if err == io.EOF { + s.allRead = true + } else if err != nil { + return false + } + return true +} + +func (s *Stream) skipWhiteSpace() byte { + p := s.bufptr() +LOOP: + c := char(p, s.cursor) + switch c { + case ' ', '\n', '\t', '\r': + s.cursor++ + goto LOOP + case nul: + if s.read() { + p = s.bufptr() + goto LOOP + } + } + return c +} + +func (s *Stream) skipObject(depth int64) error { + braceCount := 1 + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case '{': + braceCount++ + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case '}': + braceCount-- + depth-- + if braceCount == 0 { + s.cursor = cursor + 1 + return nil + } + case '[': + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case ']': + depth-- + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("object of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func (s *Stream) skipArray(depth int64) error { + bracketCount := 1 + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case '[': + bracketCount++ + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case ']': + bracketCount-- + depth-- + if bracketCount == 0 { + s.cursor = cursor + 1 + return nil + } + case '{': + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case '}': + depth-- + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("array of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func (s *Stream) skipValue(depth int64) error { + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of object", s.totalOffset()) + case '{': + s.cursor = cursor + 1 + return s.skipObject(depth + 1) + case '[': + s.cursor = cursor + 1 + return s.skipArray(depth + 1) + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset()) + } + case '"': + s.cursor = cursor + 1 + return nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset()) + } + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + for { + cursor++ + c := char(p, cursor) + if floatTable[c] { + continue + } else if c == nul { + if s.read() { + _, cursor, p = s.stat() + continue + } + } + s.cursor = cursor + return nil + } + case 't': + s.cursor = cursor + if err := trueBytes(s); err != nil { + return err + } + return nil + case 'f': + s.cursor = cursor + if err := falseBytes(s); err != nil { + return err + } + return nil + case 'n': + s.cursor = cursor + if err := nullBytes(s); err != nil { + return err + } + return nil + } + cursor++ + } +} + +func nullBytes(s *Stream) error { + // current cursor's character is 'n' + s.cursor++ + if s.char() != 'u' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadNull(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "null", s.totalOffset()) +} + +func trueBytes(s *Stream) error { + // current cursor's character is 't' + s.cursor++ + if s.char() != 'r' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'u' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'e' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadTrue(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "bool(true)", s.totalOffset()) +} + +func falseBytes(s *Stream) error { + // current cursor's character is 'f' + s.cursor++ + if s.char() != 'a' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 's' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'e' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadFalse(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "bool(false)", s.totalOffset()) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go new file mode 100644 index 00000000..32602c90 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/string.go @@ -0,0 +1,452 @@ +package decoder + +import ( + "bytes" + "fmt" + "reflect" + "unicode" + "unicode/utf16" + "unicode/utf8" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type stringDecoder struct { + structName string + fieldName string +} + +func newStringDecoder(structName, fieldName string) *stringDecoder { + return &stringDecoder{ + structName: structName, + fieldName: fieldName, + } +} + +func (d *stringDecoder) errUnmarshalType(typeName string, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: typeName, + Type: reflect.TypeOf(""), + Offset: offset, + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *stringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes)) + s.reset() + return nil +} + +func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes)) + return cursor, nil +} + +func (d *stringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return nil, 0, err + } + if bytes == nil { + return [][]byte{nullbytes}, c, nil + } + return [][]byte{bytes}, c, nil +} + +var ( + hexToInt = [256]int{ + '0': 0, + '1': 1, + '2': 2, + '3': 3, + '4': 4, + '5': 5, + '6': 6, + '7': 7, + '8': 8, + '9': 9, + 'A': 10, + 'B': 11, + 'C': 12, + 'D': 13, + 'E': 14, + 'F': 15, + 'a': 10, + 'b': 11, + 'c': 12, + 'd': 13, + 'e': 14, + 'f': 15, + } +) + +func unicodeToRune(code []byte) rune { + var r rune + for i := 0; i < len(code); i++ { + r = r*16 + rune(hexToInt[code[i]]) + } + return r +} + +func readAtLeast(s *Stream, n int64, p *unsafe.Pointer) bool { + for s.cursor+n >= s.length { + if !s.read() { + return false + } + *p = s.bufptr() + } + return true +} + +func decodeUnicodeRune(s *Stream, p unsafe.Pointer) (rune, int64, unsafe.Pointer, error) { + const defaultOffset = 5 + const surrogateOffset = 11 + + if !readAtLeast(s, defaultOffset, &p) { + return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset()) + } + + r := unicodeToRune(s.buf[s.cursor+1 : s.cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + if !readAtLeast(s, surrogateOffset, &p) { + return unicode.ReplacementChar, defaultOffset, p, nil + } + if s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' { + return unicode.ReplacementChar, defaultOffset, p, nil + } + r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + return r, surrogateOffset, p, nil + } + } + return r, defaultOffset, p, nil +} + +func decodeUnicode(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) { + const backSlashAndULen = 2 // length of \u + + r, offset, pp, err := decodeUnicodeRune(s, p) + if err != nil { + return nil, err + } + unicode := []byte(string(r)) + unicodeLen := int64(len(unicode)) + s.buf = append(append(s.buf[:s.cursor-1], unicode...), s.buf[s.cursor+offset:]...) + unicodeOrgLen := offset - 1 + s.length = s.length - (backSlashAndULen + (unicodeOrgLen - unicodeLen)) + s.cursor = s.cursor - backSlashAndULen + unicodeLen + return pp, nil +} + +func decodeEscapeString(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) { + s.cursor++ +RETRY: + switch s.buf[s.cursor] { + case '"': + s.buf[s.cursor] = '"' + case '\\': + s.buf[s.cursor] = '\\' + case '/': + s.buf[s.cursor] = '/' + case 'b': + s.buf[s.cursor] = '\b' + case 'f': + s.buf[s.cursor] = '\f' + case 'n': + s.buf[s.cursor] = '\n' + case 'r': + s.buf[s.cursor] = '\r' + case 't': + s.buf[s.cursor] = '\t' + case 'u': + return decodeUnicode(s, p) + case nul: + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset()) + } + p = s.bufptr() + goto RETRY + default: + return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + s.buf = append(s.buf[:s.cursor-1], s.buf[s.cursor:]...) + s.length-- + s.cursor-- + p = s.bufptr() + return p, nil +} + +var ( + runeErrBytes = []byte(string(utf8.RuneError)) + runeErrBytesLen = int64(len(runeErrBytes)) +) + +func stringBytes(s *Stream) ([]byte, error) { + _, cursor, p := s.stat() + cursor++ // skip double quote char + start := cursor + for { + switch char(p, cursor) { + case '\\': + s.cursor = cursor + pp, err := decodeEscapeString(s, p) + if err != nil { + return nil, err + } + p = pp + cursor = s.cursor + case '"': + literal := s.buf[start:cursor] + cursor++ + s.cursor = cursor + return literal, nil + case + // 0x00 is nul, 0x5c is '\\', 0x22 is '"' . + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, // 0x10-0x1F + 0x20, 0x21 /*0x22,*/, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, // 0x20-0x2F + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, // 0x30-0x3F + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, // 0x40-0x4F + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B /*0x5C,*/, 0x5D, 0x5E, 0x5F, // 0x50-0x5F + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, // 0x60-0x6F + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F: // 0x70-0x7F + // character is ASCII. skip to next char + case + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, // 0x80-0x8F + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // 0x90-0x9F + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // 0xA0-0xAF + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, // 0xB0-0xBF + 0xC0, 0xC1, // 0xC0-0xC1 + 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF: // 0xF5-0xFE + // character is invalid + s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...) + _, _, p = s.stat() + cursor += runeErrBytesLen + s.length += runeErrBytesLen + continue + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + goto ERROR + case 0xEF: + // RuneError is {0xEF, 0xBF, 0xBD} + if s.buf[cursor+1] == 0xBF && s.buf[cursor+2] == 0xBD { + // found RuneError: skip + cursor += 2 + break + } + fallthrough + default: + // multi bytes character + if !utf8.FullRune(s.buf[cursor : len(s.buf)-1]) { + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + goto ERROR + } + r, size := utf8.DecodeRune(s.buf[cursor:]) + if r == utf8.RuneError { + s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...) + cursor += runeErrBytesLen + s.length += runeErrBytesLen + _, _, p = s.stat() + } else { + cursor += int64(size) + } + continue + } + cursor++ + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) +} + +func (d *stringDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '[': + return nil, d.errUnmarshalType("array", s.totalOffset()) + case '{': + return nil, d.errUnmarshalType("object", s.totalOffset()) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return nil, d.errUnmarshalType("number", s.totalOffset()) + case '"': + return stringBytes(s) + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + } + break + } + return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) +} + +func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + case '[': + return nil, 0, d.errUnmarshalType("array", cursor) + case '{': + return nil, 0, d.errUnmarshalType("object", cursor) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return nil, 0, d.errUnmarshalType("number", cursor) + case '"': + cursor++ + start := cursor + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + escaped := 0 + for { + switch char(b, cursor) { + case '\\': + escaped++ + cursor++ + switch char(b, cursor) { + case '"', '\\', '/', 'b', 'f', 'n', 'r', 't': + cursor++ + case 'u': + buflen := int64(len(buf)) + if cursor+5 >= buflen { + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + for i := int64(1); i <= 4; i++ { + c := char(b, cursor+i) + if !(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) { + return nil, 0, errors.ErrSyntax(fmt.Sprintf("json: invalid character %c in \\u hexadecimal character escape", c), cursor+i) + } + } + cursor += 5 + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + continue + case '"': + literal := buf[start:cursor] + if escaped > 0 { + literal = literal[:unescapeString(literal)] + } + cursor++ + return literal, cursor, nil + case nul: + return nil, 0, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + cursor++ + } + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) + } + } +} + +var unescapeMap = [256]byte{ + '"': '"', + '\\': '\\', + '/': '/', + 'b': '\b', + 'f': '\f', + 'n': '\n', + 'r': '\r', + 't': '\t', +} + +func unsafeAdd(ptr unsafe.Pointer, offset int) unsafe.Pointer { + return unsafe.Pointer(uintptr(ptr) + uintptr(offset)) +} + +func unescapeString(buf []byte) int { + p := (*sliceHeader)(unsafe.Pointer(&buf)).data + end := unsafeAdd(p, len(buf)) + src := unsafeAdd(p, bytes.IndexByte(buf, '\\')) + dst := src + for src != end { + c := char(src, 0) + if c == '\\' { + escapeChar := char(src, 1) + if escapeChar != 'u' { + *(*byte)(dst) = unescapeMap[escapeChar] + src = unsafeAdd(src, 2) + dst = unsafeAdd(dst, 1) + } else { + v1 := hexToInt[char(src, 2)] + v2 := hexToInt[char(src, 3)] + v3 := hexToInt[char(src, 4)] + v4 := hexToInt[char(src, 5)] + code := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4) + if code >= 0xd800 && code < 0xdc00 && uintptr(unsafeAdd(src, 11)) < uintptr(end) { + if char(src, 6) == '\\' && char(src, 7) == 'u' { + v1 := hexToInt[char(src, 8)] + v2 := hexToInt[char(src, 9)] + v3 := hexToInt[char(src, 10)] + v4 := hexToInt[char(src, 11)] + lo := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4) + if lo >= 0xdc00 && lo < 0xe000 { + code = (code-0xd800)<<10 | (lo - 0xdc00) + 0x10000 + src = unsafeAdd(src, 6) + } + } + } + var b [utf8.UTFMax]byte + n := utf8.EncodeRune(b[:], code) + switch n { + case 4: + *(*byte)(unsafeAdd(dst, 3)) = b[3] + fallthrough + case 3: + *(*byte)(unsafeAdd(dst, 2)) = b[2] + fallthrough + case 2: + *(*byte)(unsafeAdd(dst, 1)) = b[1] + fallthrough + case 1: + *(*byte)(unsafeAdd(dst, 0)) = b[0] + } + src = unsafeAdd(src, 6) + dst = unsafeAdd(dst, n) + } + } else { + *(*byte)(dst) = c + src = unsafeAdd(src, 1) + dst = unsafeAdd(dst, 1) + } + } + return int(uintptr(dst) - uintptr(p)) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go new file mode 100644 index 00000000..313da153 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/struct.go @@ -0,0 +1,845 @@ +package decoder + +import ( + "fmt" + "math" + "math/bits" + "sort" + "strings" + "unicode" + "unicode/utf16" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type structFieldSet struct { + dec Decoder + offset uintptr + isTaggedKey bool + fieldIdx int + key string + keyLen int64 + err error +} + +type structDecoder struct { + fieldMap map[string]*structFieldSet + fieldUniqueNameNum int + stringDecoder *stringDecoder + structName string + fieldName string + isTriedOptimize bool + keyBitmapUint8 [][256]uint8 + keyBitmapUint16 [][256]uint16 + sortedFieldSets []*structFieldSet + keyDecoder func(*structDecoder, []byte, int64) (int64, *structFieldSet, error) + keyStreamDecoder func(*structDecoder, *Stream) (*structFieldSet, string, error) +} + +var ( + largeToSmallTable [256]byte +) + +func init() { + for i := 0; i < 256; i++ { + c := i + if 'A' <= c && c <= 'Z' { + c += 'a' - 'A' + } + largeToSmallTable[i] = byte(c) + } +} + +func toASCIILower(s string) string { + b := []byte(s) + for i := range b { + b[i] = largeToSmallTable[b[i]] + } + return string(b) +} + +func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder { + return &structDecoder{ + fieldMap: fieldMap, + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + keyDecoder: decodeKey, + keyStreamDecoder: decodeKeyStream, + } +} + +const ( + allowOptimizeMaxKeyLen = 64 + allowOptimizeMaxFieldLen = 16 +) + +func (d *structDecoder) tryOptimize() { + fieldUniqueNameMap := map[string]int{} + fieldIdx := -1 + for k, v := range d.fieldMap { + lower := strings.ToLower(k) + idx, exists := fieldUniqueNameMap[lower] + if exists { + v.fieldIdx = idx + } else { + fieldIdx++ + v.fieldIdx = fieldIdx + } + fieldUniqueNameMap[lower] = fieldIdx + } + d.fieldUniqueNameNum = len(fieldUniqueNameMap) + + if d.isTriedOptimize { + return + } + fieldMap := map[string]*structFieldSet{} + conflicted := map[string]struct{}{} + for k, v := range d.fieldMap { + key := strings.ToLower(k) + if key != k { + if key != toASCIILower(k) { + d.isTriedOptimize = true + return + } + // already exists same key (e.g. Hello and HELLO has same lower case key + if _, exists := conflicted[key]; exists { + d.isTriedOptimize = true + return + } + conflicted[key] = struct{}{} + } + if field, exists := fieldMap[key]; exists { + if field != v { + d.isTriedOptimize = true + return + } + } + fieldMap[key] = v + } + + if len(fieldMap) > allowOptimizeMaxFieldLen { + d.isTriedOptimize = true + return + } + + var maxKeyLen int + sortedKeys := []string{} + for key := range fieldMap { + keyLen := len(key) + if keyLen > allowOptimizeMaxKeyLen { + d.isTriedOptimize = true + return + } + if maxKeyLen < keyLen { + maxKeyLen = keyLen + } + sortedKeys = append(sortedKeys, key) + } + sort.Strings(sortedKeys) + + // By allocating one extra capacity than `maxKeyLen`, + // it is possible to avoid the process of comparing the index of the key with the length of the bitmap each time. + bitmapLen := maxKeyLen + 1 + if len(sortedKeys) <= 8 { + keyBitmap := make([][256]uint8, bitmapLen) + for i, key := range sortedKeys { + for j := 0; j < len(key); j++ { + c := key[j] + keyBitmap[j][c] |= (1 << uint(i)) + } + d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key]) + } + d.keyBitmapUint8 = keyBitmap + d.keyDecoder = decodeKeyByBitmapUint8 + d.keyStreamDecoder = decodeKeyByBitmapUint8Stream + } else { + keyBitmap := make([][256]uint16, bitmapLen) + for i, key := range sortedKeys { + for j := 0; j < len(key); j++ { + c := key[j] + keyBitmap[j][c] |= (1 << uint(i)) + } + d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key]) + } + d.keyBitmapUint16 = keyBitmap + d.keyDecoder = decodeKeyByBitmapUint16 + d.keyStreamDecoder = decodeKeyByBitmapUint16Stream + } +} + +// decode from '\uXXXX' +func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64, error) { + const defaultOffset = 4 + const surrogateOffset = 6 + + if cursor+defaultOffset >= int64(len(buf)) { + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + + r := unicodeToRune(buf[cursor : cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + cursor += defaultOffset + if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' { + return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1, nil + } + cursor += 2 + r2 := unicodeToRune(buf[cursor : cursor+defaultOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + return []byte(string(r)), cursor + defaultOffset - 1, nil + } + } + return []byte(string(r)), cursor + defaultOffset - 1, nil +} + +func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64, error) { + c := buf[cursor] + cursor++ + switch c { + case '"': + return []byte{'"'}, cursor, nil + case '\\': + return []byte{'\\'}, cursor, nil + case '/': + return []byte{'/'}, cursor, nil + case 'b': + return []byte{'\b'}, cursor, nil + case 'f': + return []byte{'\f'}, cursor, nil + case 'n': + return []byte{'\n'}, cursor, nil + case 'r': + return []byte{'\r'}, cursor, nil + case 't': + return []byte{'\t'}, cursor, nil + case 'u': + return decodeKeyCharByUnicodeRune(buf, cursor) + } + return nil, cursor, nil +} + +func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + var ( + curBit uint8 = math.MaxUint8 + ) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case '"': + cursor++ + c := char(b, cursor) + switch c { + case '"': + cursor++ + return cursor, nil, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + keyIdx := 0 + bitmap := d.keyBitmapUint8 + start := cursor + for { + c := char(b, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros8(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + if keyLen < field.keyLen { + // early match + return cursor, nil, nil + } + return cursor, field, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + case '\\': + cursor++ + chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor) + if err != nil { + return 0, nil, err + } + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor = nextCursor + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor++ + } + default: + return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + } +} + +func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + var ( + curBit uint16 = math.MaxUint16 + ) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case '"': + cursor++ + c := char(b, cursor) + switch c { + case '"': + cursor++ + return cursor, nil, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + keyIdx := 0 + bitmap := d.keyBitmapUint16 + start := cursor + for { + c := char(b, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros16(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + if keyLen < field.keyLen { + // early match + return cursor, nil, nil + } + return cursor, field, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + case '\\': + cursor++ + chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor) + if err != nil { + return 0, nil, err + } + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor = nextCursor + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor++ + } + default: + return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + } +} + +func decodeKeyNotFound(b unsafe.Pointer, cursor int64) (int64, *structFieldSet, error) { + for { + cursor++ + switch char(b, cursor) { + case '"': + cursor++ + return cursor, nil, nil + case '\\': + cursor++ + if char(b, cursor) == nul { + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + } +} + +func decodeKey(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + key, c, err := d.stringDecoder.decodeByte(buf, cursor) + if err != nil { + return 0, nil, err + } + cursor = c + k := *(*string)(unsafe.Pointer(&key)) + field, exists := d.fieldMap[k] + if !exists { + return cursor, nil, nil + } + return cursor, field, nil +} + +func decodeKeyByBitmapUint8Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + var ( + curBit uint8 = math.MaxUint8 + ) + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + case '"': + cursor++ + FIRST_CHAR: + start := cursor + switch char(p, cursor) { + case '"': + cursor++ + s.cursor = cursor + return nil, "", nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + goto FIRST_CHAR + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + keyIdx := 0 + bitmap := d.keyBitmapUint8 + for { + c := char(p, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros8(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + s.cursor = cursor + if keyLen < field.keyLen { + // early match + return nil, field.key, nil + } + return field, field.key, nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + case '\\': + s.cursor = cursor + 1 // skip '\' char + chars, err := decodeKeyCharByEscapeCharStream(s) + if err != nil { + return nil, "", err + } + cursor = s.cursor + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + cursor++ + } + default: + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + } + } +} + +func decodeKeyByBitmapUint16Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + var ( + curBit uint16 = math.MaxUint16 + ) + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + case '"': + cursor++ + FIRST_CHAR: + start := cursor + switch char(p, cursor) { + case '"': + cursor++ + s.cursor = cursor + return nil, "", nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + goto FIRST_CHAR + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + keyIdx := 0 + bitmap := d.keyBitmapUint16 + for { + c := char(p, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros16(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + s.cursor = cursor + if keyLen < field.keyLen { + // early match + return nil, field.key, nil + } + return field, field.key, nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + case '\\': + s.cursor = cursor + 1 // skip '\' char + chars, err := decodeKeyCharByEscapeCharStream(s) + if err != nil { + return nil, "", err + } + cursor = s.cursor + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + cursor++ + } + default: + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + } + } +} + +// decode from '\uXXXX' +func decodeKeyCharByUnicodeRuneStream(s *Stream) ([]byte, error) { + const defaultOffset = 4 + const surrogateOffset = 6 + + if s.cursor+defaultOffset >= s.length { + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped unicode char", s.totalOffset()) + } + } + + r := unicodeToRune(s.buf[s.cursor : s.cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + s.cursor += defaultOffset + if s.cursor+surrogateOffset >= s.length { + s.read() + } + if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor] != '\\' || s.buf[s.cursor+1] != 'u' { + s.cursor += defaultOffset - 1 + return []byte(string(unicode.ReplacementChar)), nil + } + r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + s.cursor += defaultOffset - 1 + return []byte(string(r)), nil + } + } + s.cursor += defaultOffset - 1 + return []byte(string(r)), nil +} + +func decodeKeyCharByEscapeCharStream(s *Stream) ([]byte, error) { + c := s.buf[s.cursor] + s.cursor++ +RETRY: + switch c { + case '"': + return []byte{'"'}, nil + case '\\': + return []byte{'\\'}, nil + case '/': + return []byte{'/'}, nil + case 'b': + return []byte{'\b'}, nil + case 'f': + return []byte{'\f'}, nil + case 'n': + return []byte{'\n'}, nil + case 'r': + return []byte{'\r'}, nil + case 't': + return []byte{'\t'}, nil + case 'u': + return decodeKeyCharByUnicodeRuneStream(s) + case nul: + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped char", s.totalOffset()) + } + goto RETRY + default: + return nil, errors.ErrUnexpectedEndOfJSON("struct field", s.totalOffset()) + } +} + +func decodeKeyNotFoundStream(s *Stream, start int64) (*structFieldSet, string, error) { + buf, cursor, p := s.stat() + for { + cursor++ + switch char(p, cursor) { + case '"': + b := buf[start:cursor] + key := *(*string)(unsafe.Pointer(&b)) + cursor++ + s.cursor = cursor + return nil, key, nil + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if !s.read() { + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + buf, cursor, p = s.statForRetry() + } + case nul: + s.cursor = cursor + if !s.read() { + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + buf, cursor, p = s.statForRetry() + } + } +} + +func decodeKeyStream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + key, err := d.stringDecoder.decodeStreamByte(s) + if err != nil { + return nil, "", err + } + k := *(*string)(unsafe.Pointer(&key)) + return d.fieldMap[k], k, nil +} + +func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + c := s.skipWhiteSpace() + switch c { + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + default: + if s.char() != '{' { + return errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) + } + } + s.cursor++ + if s.skipWhiteSpace() == '}' { + s.cursor++ + return nil + } + var ( + seenFields map[int]struct{} + seenFieldNum int + ) + firstWin := (s.Option.Flags & FirstWinOption) != 0 + if firstWin { + seenFields = make(map[int]struct{}, d.fieldUniqueNameNum) + } + for { + s.reset() + field, key, err := d.keyStreamDecoder(d, s) + if err != nil { + return err + } + if s.skipWhiteSpace() != ':' { + return errors.ErrExpected("colon after object key", s.totalOffset()) + } + s.cursor++ + if field != nil { + if field.err != nil { + return field.err + } + if firstWin { + if _, exists := seenFields[field.fieldIdx]; exists { + if err := s.skipValue(depth); err != nil { + return err + } + } else { + if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil { + return err + } + seenFieldNum++ + if d.fieldUniqueNameNum <= seenFieldNum { + return s.skipObject(depth) + } + seenFields[field.fieldIdx] = struct{}{} + } + } else { + if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil { + return err + } + } + } else if s.DisallowUnknownFields { + return fmt.Errorf("json: unknown field %q", key) + } else { + if err := s.skipValue(depth); err != nil { + return err + } + } + c := s.skipWhiteSpace() + if c == '}' { + s.cursor++ + return nil + } + if c != ',' { + return errors.ErrExpected("comma after object element", s.totalOffset()) + } + s.cursor++ + } +} + +func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + buflen := int64(len(buf)) + cursor = skipWhiteSpace(buf, cursor) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + switch char(b, cursor) { + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case '{': + default: + return 0, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '}' { + cursor++ + return cursor, nil + } + var ( + seenFields map[int]struct{} + seenFieldNum int + ) + firstWin := (ctx.Option.Flags & FirstWinOption) != 0 + if firstWin { + seenFields = make(map[int]struct{}, d.fieldUniqueNameNum) + } + for { + c, field, err := d.keyDecoder(d, buf, cursor) + if err != nil { + return 0, err + } + cursor = skipWhiteSpace(buf, c) + if char(b, cursor) != ':' { + return 0, errors.ErrExpected("colon after object key", cursor) + } + cursor++ + if cursor >= buflen { + return 0, errors.ErrExpected("object value after colon", cursor) + } + if field != nil { + if field.err != nil { + return 0, field.err + } + if firstWin { + if _, exists := seenFields[field.fieldIdx]; exists { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } else { + c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset)) + if err != nil { + return 0, err + } + cursor = c + seenFieldNum++ + if d.fieldUniqueNameNum <= seenFieldNum { + return skipObject(buf, cursor, depth) + } + seenFields[field.fieldIdx] = struct{}{} + } + } else { + c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset)) + if err != nil { + return 0, err + } + cursor = c + } + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } + cursor = skipWhiteSpace(buf, cursor) + if char(b, cursor) == '}' { + cursor++ + return cursor, nil + } + if char(b, cursor) != ',' { + return 0, errors.ErrExpected("comma after object element", cursor) + } + cursor++ + } +} + +func (d *structDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: struct decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go new file mode 100644 index 00000000..beaf3ab8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/type.go @@ -0,0 +1,30 @@ +package decoder + +import ( + "context" + "encoding" + "encoding/json" + "reflect" + "unsafe" +) + +type Decoder interface { + Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error) + DecodePath(*RuntimeContext, int64, int64) ([][]byte, int64, error) + DecodeStream(*Stream, int64, unsafe.Pointer) error +} + +const ( + nul = '\000' + maxDecodeNestingDepth = 10000 +) + +type unmarshalerContext interface { + UnmarshalJSON(context.Context, []byte) error +} + +var ( + unmarshalJSONType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + unmarshalJSONContextType = reflect.TypeOf((*unmarshalerContext)(nil)).Elem() + unmarshalTextType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() +) diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go new file mode 100644 index 00000000..4131731b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/uint.go @@ -0,0 +1,194 @@ +package decoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type uintDecoder struct { + typ *runtime.Type + kind reflect.Kind + op func(unsafe.Pointer, uint64) + structName string + fieldName string +} + +func newUintDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, uint64)) *uintDecoder { + return &uintDecoder{ + typ: typ, + kind: typ.Kind(), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *uintDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: fmt.Sprintf("number %s", string(buf)), + Type: runtime.RType2Type(d.typ), + Offset: offset, + } +} + +var ( + pow10u64 = [...]uint64{ + 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + } + pow10u64Len = len(pow10u64) +) + +func (d *uintDecoder) parseUint(b []byte) (uint64, error) { + maxDigit := len(b) + if maxDigit > pow10u64Len { + return 0, fmt.Errorf("invalid length of number") + } + sum := uint64(0) + for i := 0; i < maxDigit; i++ { + c := uint64(b[i]) - 48 + digitValue := pow10u64[maxDigit-i-1] + sum += c * digitValue + } + return sum, nil +} + +func (d *uintDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '0': + s.cursor++ + return numZeroBuf, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + return num, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + default: + return nil, d.typeError([]byte{s.char()}, s.totalOffset()) + } + break + } + return nil, errors.ErrUnexpectedEndOfJSON("number(unsigned integer)", s.totalOffset()) +} + +func (d *uintDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '0': + cursor++ + return numZeroBuf, cursor, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for numTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, d.typeError([]byte{buf[cursor]}, cursor) + } + } +} + +func (d *uintDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + u64, err := d.parseUint(bytes) + if err != nil { + return d.typeError(bytes, s.totalOffset()) + } + switch d.kind { + case reflect.Uint8: + if (1 << 8) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Uint16: + if (1 << 16) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Uint32: + if (1 << 32) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + } + d.op(p, u64) + return nil +} + +func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + u64, err := d.parseUint(bytes) + if err != nil { + return 0, d.typeError(bytes, cursor) + } + switch d.kind { + case reflect.Uint8: + if (1 << 8) <= u64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Uint16: + if (1 << 16) <= u64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Uint32: + if (1 << 32) <= u64 { + return 0, d.typeError(bytes, cursor) + } + } + d.op(p, u64) + return cursor, nil +} + +func (d *uintDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: uint decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go new file mode 100644 index 00000000..4cd6dbd5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go @@ -0,0 +1,104 @@ +package decoder + +import ( + "context" + "encoding/json" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type unmarshalJSONDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newUnmarshalJSONDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalJSONDecoder { + return &unmarshalJSONDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *unmarshalJSONDecoder) annotateError(cursor int64, err error) { + switch e := err.(type) { + case *errors.UnmarshalTypeError: + e.Struct = d.structName + e.Field = d.fieldName + case *errors.SyntaxError: + e.Offset = cursor + } +} + +func (d *unmarshalJSONDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + switch v := v.(type) { + case unmarshalerContext: + var ctx context.Context + if (s.Option.Flags & ContextOption) != 0 { + ctx = s.Option.Context + } else { + ctx = context.Background() + } + if err := v.UnmarshalJSON(ctx, dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + case json.Unmarshaler: + if err := v.UnmarshalJSON(dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + } + return nil +} + +func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + if (ctx.Option.Flags & ContextOption) != 0 { + if err := v.(unmarshalerContext).UnmarshalJSON(ctx.Option.Context, dst); err != nil { + d.annotateError(cursor, err) + return 0, err + } + } else { + if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil { + d.annotateError(cursor, err) + return 0, err + } + } + return end, nil +} + +func (d *unmarshalJSONDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: unmarshal json decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go new file mode 100644 index 00000000..d711d0f8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go @@ -0,0 +1,285 @@ +package decoder + +import ( + "bytes" + "encoding" + "fmt" + "unicode" + "unicode/utf16" + "unicode/utf8" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type unmarshalTextDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newUnmarshalTextDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalTextDecoder { + return &unmarshalTextDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *unmarshalTextDecoder) annotateError(cursor int64, err error) { + switch e := err.(type) { + case *errors.UnmarshalTypeError: + e.Struct = d.structName + e.Field = d.fieldName + case *errors.SyntaxError: + e.Offset = cursor + } +} + +var ( + nullbytes = []byte(`null`) +) + +func (d *unmarshalTextDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if len(src) > 0 { + switch src[0] { + case '[': + return &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '{': + return &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return nil + } + } + } + dst := make([]byte, len(src)) + copy(dst, src) + + if b, ok := unquoteBytes(dst); ok { + dst = b + } + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + if err := v.(encoding.TextUnmarshaler).UnmarshalText(dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + return nil +} + +func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if len(src) > 0 { + switch src[0] { + case '[': + return 0, &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '{': + return 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + } + } + + if s, ok := unquoteBytes(src); ok { + src = s + } + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) + if err := v.(encoding.TextUnmarshaler).UnmarshalText(src); err != nil { + d.annotateError(cursor, err) + return 0, err + } + return end, nil +} + +func (d *unmarshalTextDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: unmarshal text decoder does not support decode path") +} + +func unquoteBytes(s []byte) (t []byte, ok bool) { //nolint: nonamedreturns + length := len(s) + if length < 2 || s[0] != '"' || s[length-1] != '"' { + return + } + s = s[1 : length-1] + length -= 2 + + // Check for unusual characters. If there are none, + // then no unquoting is needed, so return a slice of the + // original bytes. + r := 0 + for r < length { + c := s[r] + if c == '\\' || c == '"' || c < ' ' { + break + } + if c < utf8.RuneSelf { + r++ + continue + } + rr, size := utf8.DecodeRune(s[r:]) + if rr == utf8.RuneError && size == 1 { + break + } + r += size + } + if r == length { + return s, true + } + + b := make([]byte, length+2*utf8.UTFMax) + w := copy(b, s[0:r]) + for r < length { + // Out of room? Can only happen if s is full of + // malformed UTF-8 and we're replacing each + // byte with RuneError. + if w >= len(b)-2*utf8.UTFMax { + nb := make([]byte, (len(b)+utf8.UTFMax)*2) + copy(nb, b[0:w]) + b = nb + } + switch c := s[r]; { + case c == '\\': + r++ + if r >= length { + return + } + switch s[r] { + default: + return + case '"', '\\', '/', '\'': + b[w] = s[r] + r++ + w++ + case 'b': + b[w] = '\b' + r++ + w++ + case 'f': + b[w] = '\f' + r++ + w++ + case 'n': + b[w] = '\n' + r++ + w++ + case 'r': + b[w] = '\r' + r++ + w++ + case 't': + b[w] = '\t' + r++ + w++ + case 'u': + r-- + rr := getu4(s[r:]) + if rr < 0 { + return + } + r += 6 + if utf16.IsSurrogate(rr) { + rr1 := getu4(s[r:]) + if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { + // A valid pair; consume. + r += 6 + w += utf8.EncodeRune(b[w:], dec) + break + } + // Invalid surrogate; fall back to replacement rune. + rr = unicode.ReplacementChar + } + w += utf8.EncodeRune(b[w:], rr) + } + + // Quote, control characters are invalid. + case c == '"', c < ' ': + return + + // ASCII + case c < utf8.RuneSelf: + b[w] = c + r++ + w++ + + // Coerce to well-formed UTF-8. + default: + rr, size := utf8.DecodeRune(s[r:]) + r += size + w += utf8.EncodeRune(b[w:], rr) + } + } + return b[0:w], true +} + +func getu4(s []byte) rune { + if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { + return -1 + } + var r rune + for _, c := range s[2:6] { + switch { + case '0' <= c && c <= '9': + c = c - '0' + case 'a' <= c && c <= 'f': + c = c - 'a' + 10 + case 'A' <= c && c <= 'F': + c = c - 'A' + 10 + default: + return -1 + } + r = r*16 + rune(c) + } + return r +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go new file mode 100644 index 00000000..0c4e2e6e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go @@ -0,0 +1,73 @@ +package decoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type wrappedStringDecoder struct { + typ *runtime.Type + dec Decoder + stringDecoder *stringDecoder + structName string + fieldName string + isPtrType bool +} + +func newWrappedStringDecoder(typ *runtime.Type, dec Decoder, structName, fieldName string) *wrappedStringDecoder { + return &wrappedStringDecoder{ + typ: typ, + dec: dec, + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + isPtrType: typ.Kind() == reflect.Ptr, + } +} + +func (d *wrappedStringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.stringDecoder.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + if d.isPtrType { + *(*unsafe.Pointer)(p) = nil + } + return nil + } + b := make([]byte, len(bytes)+1) + copy(b, bytes) + if _, err := d.dec.Decode(&RuntimeContext{Buf: b}, 0, depth, p); err != nil { + return err + } + return nil +} + +func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.stringDecoder.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + if d.isPtrType { + *(*unsafe.Pointer)(p) = nil + } + return c, nil + } + bytes = append(bytes, nul) + oldBuf := ctx.Buf + ctx.Buf = bytes + if _, err := d.dec.Decode(ctx, 0, depth, p); err != nil { + return 0, err + } + ctx.Buf = oldBuf + return c, nil +} + +func (d *wrappedStringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) { + return nil, 0, fmt.Errorf("json: wrapped string decoder does not support decode path") +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/code.go b/vendor/github.com/goccy/go-json/internal/encoder/code.go new file mode 100644 index 00000000..fec45a4b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/code.go @@ -0,0 +1,1024 @@ +package encoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type Code interface { + Kind() CodeKind + ToOpcode(*compileContext) Opcodes + Filter(*FieldQuery) Code +} + +type AnonymousCode interface { + ToAnonymousOpcode(*compileContext) Opcodes +} + +type Opcodes []*Opcode + +func (o Opcodes) First() *Opcode { + if len(o) == 0 { + return nil + } + return o[0] +} + +func (o Opcodes) Last() *Opcode { + if len(o) == 0 { + return nil + } + return o[len(o)-1] +} + +func (o Opcodes) Add(codes ...*Opcode) Opcodes { + return append(o, codes...) +} + +type CodeKind int + +const ( + CodeKindInterface CodeKind = iota + CodeKindPtr + CodeKindInt + CodeKindUint + CodeKindFloat + CodeKindString + CodeKindBool + CodeKindStruct + CodeKindMap + CodeKindSlice + CodeKindArray + CodeKindBytes + CodeKindMarshalJSON + CodeKindMarshalText + CodeKindRecursive +) + +type IntCode struct { + typ *runtime.Type + bitSize uint8 + isString bool + isPtr bool +} + +func (c *IntCode) Kind() CodeKind { + return CodeKindInt +} + +func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + code = newOpCode(ctx, c.typ, OpIntPtr) + case c.isString: + code = newOpCode(ctx, c.typ, OpIntString) + default: + code = newOpCode(ctx, c.typ, OpInt) + } + code.NumBitSize = c.bitSize + ctx.incIndex() + return Opcodes{code} +} + +func (c *IntCode) Filter(_ *FieldQuery) Code { + return c +} + +type UintCode struct { + typ *runtime.Type + bitSize uint8 + isString bool + isPtr bool +} + +func (c *UintCode) Kind() CodeKind { + return CodeKindUint +} + +func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + code = newOpCode(ctx, c.typ, OpUintPtr) + case c.isString: + code = newOpCode(ctx, c.typ, OpUintString) + default: + code = newOpCode(ctx, c.typ, OpUint) + } + code.NumBitSize = c.bitSize + ctx.incIndex() + return Opcodes{code} +} + +func (c *UintCode) Filter(_ *FieldQuery) Code { + return c +} + +type FloatCode struct { + typ *runtime.Type + bitSize uint8 + isPtr bool +} + +func (c *FloatCode) Kind() CodeKind { + return CodeKindFloat +} + +func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + switch c.bitSize { + case 32: + code = newOpCode(ctx, c.typ, OpFloat32Ptr) + default: + code = newOpCode(ctx, c.typ, OpFloat64Ptr) + } + default: + switch c.bitSize { + case 32: + code = newOpCode(ctx, c.typ, OpFloat32) + default: + code = newOpCode(ctx, c.typ, OpFloat64) + } + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *FloatCode) Filter(_ *FieldQuery) Code { + return c +} + +type StringCode struct { + typ *runtime.Type + isPtr bool +} + +func (c *StringCode) Kind() CodeKind { + return CodeKindString +} + +func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes { + isJSONNumberType := c.typ == runtime.Type2RType(jsonNumberType) + var code *Opcode + if c.isPtr { + if isJSONNumberType { + code = newOpCode(ctx, c.typ, OpNumberPtr) + } else { + code = newOpCode(ctx, c.typ, OpStringPtr) + } + } else { + if isJSONNumberType { + code = newOpCode(ctx, c.typ, OpNumber) + } else { + code = newOpCode(ctx, c.typ, OpString) + } + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *StringCode) Filter(_ *FieldQuery) Code { + return c +} + +type BoolCode struct { + typ *runtime.Type + isPtr bool +} + +func (c *BoolCode) Kind() CodeKind { + return CodeKindBool +} + +func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + code = newOpCode(ctx, c.typ, OpBoolPtr) + default: + code = newOpCode(ctx, c.typ, OpBool) + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *BoolCode) Filter(_ *FieldQuery) Code { + return c +} + +type BytesCode struct { + typ *runtime.Type + isPtr bool +} + +func (c *BytesCode) Kind() CodeKind { + return CodeKindBytes +} + +func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + code = newOpCode(ctx, c.typ, OpBytesPtr) + default: + code = newOpCode(ctx, c.typ, OpBytes) + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *BytesCode) Filter(_ *FieldQuery) Code { + return c +} + +type SliceCode struct { + typ *runtime.Type + value Code +} + +func (c *SliceCode) Kind() CodeKind { + return CodeKindSlice +} + +func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes { + // header => opcode => elem => end + // ^ | + // |________| + size := c.typ.Elem().Size() + header := newSliceHeaderCode(ctx, c.typ) + ctx.incIndex() + + ctx.incIndent() + codes := c.value.ToOpcode(ctx) + ctx.decIndent() + + codes.First().Flags |= IndirectFlags + elemCode := newSliceElemCode(ctx, c.typ.Elem(), header, size) + ctx.incIndex() + end := newOpCode(ctx, c.typ, OpSliceEnd) + ctx.incIndex() + header.End = end + header.Next = codes.First() + codes.Last().Next = elemCode + elemCode.Next = codes.First() + elemCode.End = end + return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) +} + +func (c *SliceCode) Filter(_ *FieldQuery) Code { + return c +} + +type ArrayCode struct { + typ *runtime.Type + value Code +} + +func (c *ArrayCode) Kind() CodeKind { + return CodeKindArray +} + +func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes { + // header => opcode => elem => end + // ^ | + // |________| + elem := c.typ.Elem() + alen := c.typ.Len() + size := elem.Size() + + header := newArrayHeaderCode(ctx, c.typ, alen) + ctx.incIndex() + + ctx.incIndent() + codes := c.value.ToOpcode(ctx) + ctx.decIndent() + + codes.First().Flags |= IndirectFlags + + elemCode := newArrayElemCode(ctx, elem, header, alen, size) + ctx.incIndex() + + end := newOpCode(ctx, c.typ, OpArrayEnd) + ctx.incIndex() + + header.End = end + header.Next = codes.First() + codes.Last().Next = elemCode + elemCode.Next = codes.First() + elemCode.End = end + + return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) +} + +func (c *ArrayCode) Filter(_ *FieldQuery) Code { + return c +} + +type MapCode struct { + typ *runtime.Type + key Code + value Code +} + +func (c *MapCode) Kind() CodeKind { + return CodeKindMap +} + +func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes { + // header => code => value => code => key => code => value => code => end + // ^ | + // |_______________________| + header := newMapHeaderCode(ctx, c.typ) + ctx.incIndex() + + keyCodes := c.key.ToOpcode(ctx) + + value := newMapValueCode(ctx, c.typ.Elem(), header) + ctx.incIndex() + + ctx.incIndent() + valueCodes := c.value.ToOpcode(ctx) + ctx.decIndent() + + valueCodes.First().Flags |= IndirectFlags + + key := newMapKeyCode(ctx, c.typ.Key(), header) + ctx.incIndex() + + end := newMapEndCode(ctx, c.typ, header) + ctx.incIndex() + + header.Next = keyCodes.First() + keyCodes.Last().Next = value + value.Next = valueCodes.First() + valueCodes.Last().Next = key + key.Next = keyCodes.First() + + header.End = end + key.End = end + value.End = end + return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end) +} + +func (c *MapCode) Filter(_ *FieldQuery) Code { + return c +} + +type StructCode struct { + typ *runtime.Type + fields []*StructFieldCode + isPtr bool + disableIndirectConversion bool + isIndirect bool + isRecursive bool +} + +func (c *StructCode) Kind() CodeKind { + return CodeKindStruct +} + +func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode { + if isEmbeddedStruct(field) { + return c.lastAnonymousFieldCode(firstField) + } + lastField := firstField + for lastField.NextField != nil { + lastField = lastField.NextField + } + return lastField +} + +func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode { + // firstField is special StructHead operation for anonymous structure. + // So, StructHead's next operation is truly struct head operation. + for firstField.Op == OpStructHead || firstField.Op == OpStructField { + firstField = firstField.Next + } + lastField := firstField + for lastField.NextField != nil { + lastField = lastField.NextField + } + return lastField +} + +func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes { + // header => code => structField => code => end + // ^ | + // |__________| + if c.isRecursive { + recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) + recursive.Type = c.typ + ctx.incIndex() + *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) + return Opcodes{recursive} + } + codes := Opcodes{} + var prevField *Opcode + ctx.incIndent() + for idx, field := range c.fields { + isFirstField := idx == 0 + isEndField := idx == len(c.fields)-1 + fieldCodes := field.ToOpcode(ctx, isFirstField, isEndField) + for _, code := range fieldCodes { + if c.isIndirect { + code.Flags |= IndirectFlags + } + } + firstField := fieldCodes.First() + if len(codes) > 0 { + codes.Last().Next = firstField + firstField.Idx = codes.First().Idx + } + if prevField != nil { + prevField.NextField = firstField + } + if isEndField { + endField := fieldCodes.Last() + if len(codes) > 0 { + codes.First().End = endField + } else { + firstField.End = endField + } + codes = codes.Add(fieldCodes...) + break + } + prevField = c.lastFieldCode(field, firstField) + codes = codes.Add(fieldCodes...) + } + if len(codes) == 0 { + head := &Opcode{ + Op: OpStructHead, + Idx: opcodeOffset(ctx.ptrIndex), + Type: c.typ, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } + ctx.incOpcodeIndex() + end := &Opcode{ + Op: OpStructEnd, + Idx: opcodeOffset(ctx.ptrIndex), + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } + head.NextField = end + head.Next = end + head.End = end + codes = codes.Add(head, end) + ctx.incIndex() + } + ctx.decIndent() + ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes + return codes +} + +func (c *StructCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { + // header => code => structField => code => end + // ^ | + // |__________| + if c.isRecursive { + recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) + recursive.Type = c.typ + ctx.incIndex() + *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) + return Opcodes{recursive} + } + codes := Opcodes{} + var prevField *Opcode + for idx, field := range c.fields { + isFirstField := idx == 0 + isEndField := idx == len(c.fields)-1 + fieldCodes := field.ToAnonymousOpcode(ctx, isFirstField, isEndField) + for _, code := range fieldCodes { + if c.isIndirect { + code.Flags |= IndirectFlags + } + } + firstField := fieldCodes.First() + if len(codes) > 0 { + codes.Last().Next = firstField + firstField.Idx = codes.First().Idx + } + if prevField != nil { + prevField.NextField = firstField + } + if isEndField { + lastField := fieldCodes.Last() + if len(codes) > 0 { + codes.First().End = lastField + } else { + firstField.End = lastField + } + } + prevField = firstField + codes = codes.Add(fieldCodes...) + } + ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes + return codes +} + +func (c *StructCode) removeFieldsByTags(tags runtime.StructTags) { + fields := make([]*StructFieldCode, 0, len(c.fields)) + for _, field := range c.fields { + if field.isAnonymous { + structCode := field.getAnonymousStruct() + if structCode != nil && !structCode.isRecursive { + structCode.removeFieldsByTags(tags) + if len(structCode.fields) > 0 { + fields = append(fields, field) + } + continue + } + } + if tags.ExistsKey(field.key) { + continue + } + fields = append(fields, field) + } + c.fields = fields +} + +func (c *StructCode) enableIndirect() { + if c.isIndirect { + return + } + c.isIndirect = true + if len(c.fields) == 0 { + return + } + structCode := c.fields[0].getStruct() + if structCode == nil { + return + } + structCode.enableIndirect() +} + +func (c *StructCode) Filter(query *FieldQuery) Code { + fieldMap := map[string]*FieldQuery{} + for _, field := range query.Fields { + fieldMap[field.Name] = field + } + fields := make([]*StructFieldCode, 0, len(c.fields)) + for _, field := range c.fields { + query, exists := fieldMap[field.key] + if !exists { + continue + } + fieldCode := &StructFieldCode{ + typ: field.typ, + key: field.key, + tag: field.tag, + value: field.value, + offset: field.offset, + isAnonymous: field.isAnonymous, + isTaggedKey: field.isTaggedKey, + isNilableType: field.isNilableType, + isNilCheck: field.isNilCheck, + isAddrForMarshaler: field.isAddrForMarshaler, + isNextOpPtrType: field.isNextOpPtrType, + } + if len(query.Fields) > 0 { + fieldCode.value = fieldCode.value.Filter(query) + } + fields = append(fields, fieldCode) + } + return &StructCode{ + typ: c.typ, + fields: fields, + isPtr: c.isPtr, + disableIndirectConversion: c.disableIndirectConversion, + isIndirect: c.isIndirect, + isRecursive: c.isRecursive, + } +} + +type StructFieldCode struct { + typ *runtime.Type + key string + tag *runtime.StructTag + value Code + offset uintptr + isAnonymous bool + isTaggedKey bool + isNilableType bool + isNilCheck bool + isAddrForMarshaler bool + isNextOpPtrType bool + isMarshalerContext bool +} + +func (c *StructFieldCode) getStruct() *StructCode { + value := c.value + ptr, ok := value.(*PtrCode) + if ok { + value = ptr.value + } + structCode, ok := value.(*StructCode) + if ok { + return structCode + } + return nil +} + +func (c *StructFieldCode) getAnonymousStruct() *StructCode { + if !c.isAnonymous { + return nil + } + return c.getStruct() +} + +func optimizeStructHeader(code *Opcode, tag *runtime.StructTag) OpType { + headType := code.ToHeaderType(tag.IsString) + if tag.IsOmitEmpty { + headType = headType.HeadToOmitEmptyHead() + } + return headType +} + +func optimizeStructField(code *Opcode, tag *runtime.StructTag) OpType { + fieldType := code.ToFieldType(tag.IsString) + if tag.IsOmitEmpty { + fieldType = fieldType.FieldToOmitEmptyField() + } + return fieldType +} + +func (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { + value := valueCodes.First() + op := optimizeStructHeader(value, c.tag) + field.Op = op + if value.Flags&MarshalerContextFlags != 0 { + field.Flags |= MarshalerContextFlags + } + field.NumBitSize = value.NumBitSize + field.PtrNum = value.PtrNum + field.FieldQuery = value.FieldQuery + fieldCodes := Opcodes{field} + if op.IsMultipleOpHead() { + field.Next = value + fieldCodes = fieldCodes.Add(valueCodes...) + } else { + ctx.decIndex() + } + return fieldCodes +} + +func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { + value := valueCodes.First() + op := optimizeStructField(value, c.tag) + field.Op = op + if value.Flags&MarshalerContextFlags != 0 { + field.Flags |= MarshalerContextFlags + } + field.NumBitSize = value.NumBitSize + field.PtrNum = value.PtrNum + field.FieldQuery = value.FieldQuery + + fieldCodes := Opcodes{field} + if op.IsMultipleOpField() { + field.Next = value + fieldCodes = fieldCodes.Add(valueCodes...) + } else { + ctx.decIndex() + } + return fieldCodes +} + +func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) Opcodes { + end := &Opcode{ + Op: OpStructEnd, + Idx: opcodeOffset(ctx.ptrIndex), + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } + codes.Last().Next = end + code := codes.First() + for code.Op == OpStructField || code.Op == OpStructHead { + code = code.Next + } + for code.NextField != nil { + code = code.NextField + } + code.NextField = end + + codes = codes.Add(end) + ctx.incOpcodeIndex() + return codes +} + +func (c *StructFieldCode) structKey(ctx *compileContext) string { + if ctx.escapeKey { + rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}} + return fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, c.key))) + } + return fmt.Sprintf(`"%s":`, c.key) +} + +func (c *StructFieldCode) flags() OpFlags { + var flags OpFlags + if c.isTaggedKey { + flags |= IsTaggedKeyFlags + } + if c.isNilableType { + flags |= IsNilableTypeFlags + } + if c.isNilCheck { + flags |= NilCheckFlags + } + if c.isAddrForMarshaler { + flags |= AddrForMarshalerFlags + } + if c.isNextOpPtrType { + flags |= IsNextOpPtrTypeFlags + } + if c.isAnonymous { + flags |= AnonymousKeyFlags + } + if c.isMarshalerContext { + flags |= MarshalerContextFlags + } + return flags +} + +func (c *StructFieldCode) toValueOpcodes(ctx *compileContext) Opcodes { + if c.isAnonymous { + anonymCode, ok := c.value.(AnonymousCode) + if ok { + return anonymCode.ToAnonymousOpcode(ctx) + } + } + return c.value.ToOpcode(ctx) +} + +func (c *StructFieldCode) ToOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { + field := &Opcode{ + Idx: opcodeOffset(ctx.ptrIndex), + Flags: c.flags(), + Key: c.structKey(ctx), + Offset: uint32(c.offset), + Type: c.typ, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + DisplayKey: c.key, + } + ctx.incIndex() + valueCodes := c.toValueOpcodes(ctx) + if isFirstField { + codes := c.headerOpcodes(ctx, field, valueCodes) + if isEndField { + codes = c.addStructEndCode(ctx, codes) + } + return codes + } + codes := c.fieldOpcodes(ctx, field, valueCodes) + if isEndField { + if isEnableStructEndOptimization(c.value) { + field.Op = field.Op.FieldToEnd() + } else { + codes = c.addStructEndCode(ctx, codes) + } + } + return codes +} + +func (c *StructFieldCode) ToAnonymousOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { + field := &Opcode{ + Idx: opcodeOffset(ctx.ptrIndex), + Flags: c.flags() | AnonymousHeadFlags, + Key: c.structKey(ctx), + Offset: uint32(c.offset), + Type: c.typ, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + DisplayKey: c.key, + } + ctx.incIndex() + valueCodes := c.toValueOpcodes(ctx) + if isFirstField { + return c.headerOpcodes(ctx, field, valueCodes) + } + return c.fieldOpcodes(ctx, field, valueCodes) +} + +func isEnableStructEndOptimization(value Code) bool { + switch value.Kind() { + case CodeKindInt, + CodeKindUint, + CodeKindFloat, + CodeKindString, + CodeKindBool, + CodeKindBytes: + return true + case CodeKindPtr: + return isEnableStructEndOptimization(value.(*PtrCode).value) + default: + return false + } +} + +type InterfaceCode struct { + typ *runtime.Type + fieldQuery *FieldQuery + isPtr bool +} + +func (c *InterfaceCode) Kind() CodeKind { + return CodeKindInterface +} + +func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes { + var code *Opcode + switch { + case c.isPtr: + code = newOpCode(ctx, c.typ, OpInterfacePtr) + default: + code = newOpCode(ctx, c.typ, OpInterface) + } + code.FieldQuery = c.fieldQuery + if c.typ.NumMethod() > 0 { + code.Flags |= NonEmptyInterfaceFlags + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *InterfaceCode) Filter(query *FieldQuery) Code { + return &InterfaceCode{ + typ: c.typ, + fieldQuery: query, + isPtr: c.isPtr, + } +} + +type MarshalJSONCode struct { + typ *runtime.Type + fieldQuery *FieldQuery + isAddrForMarshaler bool + isNilableType bool + isMarshalerContext bool +} + +func (c *MarshalJSONCode) Kind() CodeKind { + return CodeKindMarshalJSON +} + +func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes { + code := newOpCode(ctx, c.typ, OpMarshalJSON) + code.FieldQuery = c.fieldQuery + if c.isAddrForMarshaler { + code.Flags |= AddrForMarshalerFlags + } + if c.isMarshalerContext { + code.Flags |= MarshalerContextFlags + } + if c.isNilableType { + code.Flags |= IsNilableTypeFlags + } else { + code.Flags &= ^IsNilableTypeFlags + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *MarshalJSONCode) Filter(query *FieldQuery) Code { + return &MarshalJSONCode{ + typ: c.typ, + fieldQuery: query, + isAddrForMarshaler: c.isAddrForMarshaler, + isNilableType: c.isNilableType, + isMarshalerContext: c.isMarshalerContext, + } +} + +type MarshalTextCode struct { + typ *runtime.Type + fieldQuery *FieldQuery + isAddrForMarshaler bool + isNilableType bool +} + +func (c *MarshalTextCode) Kind() CodeKind { + return CodeKindMarshalText +} + +func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes { + code := newOpCode(ctx, c.typ, OpMarshalText) + code.FieldQuery = c.fieldQuery + if c.isAddrForMarshaler { + code.Flags |= AddrForMarshalerFlags + } + if c.isNilableType { + code.Flags |= IsNilableTypeFlags + } else { + code.Flags &= ^IsNilableTypeFlags + } + ctx.incIndex() + return Opcodes{code} +} + +func (c *MarshalTextCode) Filter(query *FieldQuery) Code { + return &MarshalTextCode{ + typ: c.typ, + fieldQuery: query, + isAddrForMarshaler: c.isAddrForMarshaler, + isNilableType: c.isNilableType, + } +} + +type PtrCode struct { + typ *runtime.Type + value Code + ptrNum uint8 +} + +func (c *PtrCode) Kind() CodeKind { + return CodeKindPtr +} + +func (c *PtrCode) ToOpcode(ctx *compileContext) Opcodes { + codes := c.value.ToOpcode(ctx) + codes.First().Op = convertPtrOp(codes.First()) + codes.First().PtrNum = c.ptrNum + return codes +} + +func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { + var codes Opcodes + anonymCode, ok := c.value.(AnonymousCode) + if ok { + codes = anonymCode.ToAnonymousOpcode(ctx) + } else { + codes = c.value.ToOpcode(ctx) + } + codes.First().Op = convertPtrOp(codes.First()) + codes.First().PtrNum = c.ptrNum + return codes +} + +func (c *PtrCode) Filter(query *FieldQuery) Code { + return &PtrCode{ + typ: c.typ, + value: c.value.Filter(query), + ptrNum: c.ptrNum, + } +} + +func convertPtrOp(code *Opcode) OpType { + ptrHeadOp := code.Op.HeadToPtrHead() + if code.Op != ptrHeadOp { + if code.PtrNum > 0 { + // ptr field and ptr head + code.PtrNum-- + } + return ptrHeadOp + } + switch code.Op { + case OpInt: + return OpIntPtr + case OpUint: + return OpUintPtr + case OpFloat32: + return OpFloat32Ptr + case OpFloat64: + return OpFloat64Ptr + case OpString: + return OpStringPtr + case OpBool: + return OpBoolPtr + case OpBytes: + return OpBytesPtr + case OpNumber: + return OpNumberPtr + case OpArray: + return OpArrayPtr + case OpSlice: + return OpSlicePtr + case OpMap: + return OpMapPtr + case OpMarshalJSON: + return OpMarshalJSONPtr + case OpMarshalText: + return OpMarshalTextPtr + case OpInterface: + return OpInterfacePtr + case OpRecursive: + return OpRecursivePtr + } + return code.Op +} + +func isEmbeddedStruct(field *StructFieldCode) bool { + if !field.isAnonymous { + return false + } + t := field.typ + if t.Kind() == reflect.Ptr { + t = t.Elem() + } + return t.Kind() == reflect.Struct +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compact.go b/vendor/github.com/goccy/go-json/internal/encoder/compact.go new file mode 100644 index 00000000..e287a6c0 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/compact.go @@ -0,0 +1,286 @@ +package encoder + +import ( + "bytes" + "fmt" + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +var ( + isWhiteSpace = [256]bool{ + ' ': true, + '\n': true, + '\t': true, + '\r': true, + } + isHTMLEscapeChar = [256]bool{ + '<': true, + '>': true, + '&': true, + } + nul = byte('\000') +) + +func Compact(buf *bytes.Buffer, src []byte, escape bool) error { + if len(src) == 0 { + return errors.ErrUnexpectedEndOfJSON("", 0) + } + buf.Grow(len(src)) + dst := buf.Bytes() + + ctx := TakeRuntimeContext() + ctxBuf := ctx.Buf[:0] + ctxBuf = append(append(ctxBuf, src...), nul) + ctx.Buf = ctxBuf + + if err := compactAndWrite(buf, dst, ctxBuf, escape); err != nil { + ReleaseRuntimeContext(ctx) + return err + } + ReleaseRuntimeContext(ctx) + return nil +} + +func compactAndWrite(buf *bytes.Buffer, dst []byte, src []byte, escape bool) error { + dst, err := compact(dst, src, escape) + if err != nil { + return err + } + if _, err := buf.Write(dst); err != nil { + return err + } + return nil +} + +func compact(dst, src []byte, escape bool) ([]byte, error) { + buf, cursor, err := compactValue(dst, src, 0, escape) + if err != nil { + return nil, err + } + if err := validateEndBuf(src, cursor); err != nil { + return nil, err + } + return buf, nil +} + +func validateEndBuf(src []byte, cursor int64) error { + for { + switch src[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case nul: + return nil + } + return errors.ErrSyntax( + fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]), + cursor+1, + ) + } +} + +func skipWhiteSpace(buf []byte, cursor int64) int64 { +LOOP: + if isWhiteSpace[buf[cursor]] { + cursor++ + goto LOOP + } + return cursor +} + +func compactValue(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) { + for { + switch src[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case '{': + return compactObject(dst, src, cursor, escape) + case '}': + return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor) + case '[': + return compactArray(dst, src, cursor, escape) + case ']': + return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor) + case '"': + return compactString(dst, src, cursor, escape) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return compactNumber(dst, src, cursor) + case 't': + return compactTrue(dst, src, cursor) + case 'f': + return compactFalse(dst, src, cursor) + case 'n': + return compactNull(dst, src, cursor) + default: + return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor) + } + } +} + +func compactObject(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) { + if src[cursor] == '{' { + dst = append(dst, '{') + } else { + return nil, 0, errors.ErrExpected("expected { character for object value", cursor) + } + cursor = skipWhiteSpace(src, cursor+1) + if src[cursor] == '}' { + dst = append(dst, '}') + return dst, cursor + 1, nil + } + var err error + for { + cursor = skipWhiteSpace(src, cursor) + dst, cursor, err = compactString(dst, src, cursor, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + if src[cursor] != ':' { + return nil, 0, errors.ErrExpected("colon after object key", cursor) + } + dst = append(dst, ':') + dst, cursor, err = compactValue(dst, src, cursor+1, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + switch src[cursor] { + case '}': + dst = append(dst, '}') + cursor++ + return dst, cursor, nil + case ',': + dst = append(dst, ',') + default: + return nil, 0, errors.ErrExpected("comma after object value", cursor) + } + cursor++ + } +} + +func compactArray(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) { + if src[cursor] == '[' { + dst = append(dst, '[') + } else { + return nil, 0, errors.ErrExpected("expected [ character for array value", cursor) + } + cursor = skipWhiteSpace(src, cursor+1) + if src[cursor] == ']' { + dst = append(dst, ']') + return dst, cursor + 1, nil + } + var err error + for { + dst, cursor, err = compactValue(dst, src, cursor, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + switch src[cursor] { + case ']': + dst = append(dst, ']') + cursor++ + return dst, cursor, nil + case ',': + dst = append(dst, ',') + default: + return nil, 0, errors.ErrExpected("comma after array value", cursor) + } + cursor++ + } +} + +func compactString(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) { + if src[cursor] != '"' { + return nil, 0, errors.ErrInvalidCharacter(src[cursor], "string", cursor) + } + start := cursor + for { + cursor++ + c := src[cursor] + if escape { + if isHTMLEscapeChar[c] { + dst = append(dst, src[start:cursor]...) + dst = append(dst, `\u00`...) + dst = append(dst, hex[c>>4], hex[c&0xF]) + start = cursor + 1 + } else if c == 0xE2 && cursor+2 < int64(len(src)) && src[cursor+1] == 0x80 && src[cursor+2]&^1 == 0xA8 { + dst = append(dst, src[start:cursor]...) + dst = append(dst, `\u202`...) + dst = append(dst, hex[src[cursor+2]&0xF]) + start = cursor + 3 + cursor += 2 + } + } + switch c { + case '\\': + cursor++ + if src[cursor] == nul { + return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src))) + } + case '"': + cursor++ + return append(dst, src[start:cursor]...), cursor, nil + case nul: + return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src))) + } + } +} + +func compactNumber(dst, src []byte, cursor int64) ([]byte, int64, error) { + start := cursor + for { + cursor++ + if floatTable[src[cursor]] { + continue + } + break + } + num := src[start:cursor] + if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&num)), 64); err != nil { + return nil, 0, err + } + dst = append(dst, num...) + return dst, cursor, nil +} + +func compactTrue(dst, src []byte, cursor int64) ([]byte, int64, error) { + if cursor+3 >= int64(len(src)) { + return nil, 0, errors.ErrUnexpectedEndOfJSON("true", cursor) + } + if !bytes.Equal(src[cursor:cursor+4], []byte(`true`)) { + return nil, 0, errors.ErrInvalidCharacter(src[cursor], "true", cursor) + } + dst = append(dst, "true"...) + cursor += 4 + return dst, cursor, nil +} + +func compactFalse(dst, src []byte, cursor int64) ([]byte, int64, error) { + if cursor+4 >= int64(len(src)) { + return nil, 0, errors.ErrUnexpectedEndOfJSON("false", cursor) + } + if !bytes.Equal(src[cursor:cursor+5], []byte(`false`)) { + return nil, 0, errors.ErrInvalidCharacter(src[cursor], "false", cursor) + } + dst = append(dst, "false"...) + cursor += 5 + return dst, cursor, nil +} + +func compactNull(dst, src []byte, cursor int64) ([]byte, int64, error) { + if cursor+3 >= int64(len(src)) { + return nil, 0, errors.ErrUnexpectedEndOfJSON("null", cursor) + } + if !bytes.Equal(src[cursor:cursor+4], []byte(`null`)) { + return nil, 0, errors.ErrInvalidCharacter(src[cursor], "null", cursor) + } + dst = append(dst, "null"...) + cursor += 4 + return dst, cursor, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go new file mode 100644 index 00000000..b1076368 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go @@ -0,0 +1,939 @@ +package encoder + +import ( + "context" + "encoding" + "encoding/json" + "reflect" + "sync" + "sync/atomic" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type marshalerContext interface { + MarshalJSON(context.Context) ([]byte, error) +} + +var ( + marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem() + marshalJSONContextType = reflect.TypeOf((*marshalerContext)(nil)).Elem() + marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() + jsonNumberType = reflect.TypeOf(json.Number("")) + cachedOpcodeSets []*OpcodeSet + cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet + typeAddr *runtime.TypeAddr + initEncoderOnce sync.Once +) + +func initEncoder() { + initEncoderOnce.Do(func() { + typeAddr = runtime.AnalyzeTypeAddr() + if typeAddr == nil { + typeAddr = &runtime.TypeAddr{} + } + cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift+1) + }) +} + +func loadOpcodeMap() map[uintptr]*OpcodeSet { + p := atomic.LoadPointer(&cachedOpcodeMap) + return *(*map[uintptr]*OpcodeSet)(unsafe.Pointer(&p)) +} + +func storeOpcodeSet(typ uintptr, set *OpcodeSet, m map[uintptr]*OpcodeSet) { + newOpcodeMap := make(map[uintptr]*OpcodeSet, len(m)+1) + newOpcodeMap[typ] = set + + for k, v := range m { + newOpcodeMap[k] = v + } + + atomic.StorePointer(&cachedOpcodeMap, *(*unsafe.Pointer)(unsafe.Pointer(&newOpcodeMap))) +} + +func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) { + opcodeMap := loadOpcodeMap() + if codeSet, exists := opcodeMap[typeptr]; exists { + return codeSet, nil + } + codeSet, err := newCompiler().compile(typeptr) + if err != nil { + return nil, err + } + storeOpcodeSet(typeptr, codeSet, opcodeMap) + return codeSet, nil +} + +func getFilteredCodeSetIfNeeded(ctx *RuntimeContext, codeSet *OpcodeSet) (*OpcodeSet, error) { + if (ctx.Option.Flag & ContextOption) == 0 { + return codeSet, nil + } + query := FieldQueryFromContext(ctx.Option.Context) + if query == nil { + return codeSet, nil + } + ctx.Option.Flag |= FieldQueryOption + cacheCodeSet := codeSet.getQueryCache(query.Hash()) + if cacheCodeSet != nil { + return cacheCodeSet, nil + } + queryCodeSet, err := newCompiler().codeToOpcodeSet(codeSet.Type, codeSet.Code.Filter(query)) + if err != nil { + return nil, err + } + codeSet.setQueryCache(query.Hash(), queryCodeSet) + return queryCodeSet, nil +} + +type Compiler struct { + structTypeToCode map[uintptr]*StructCode +} + +func newCompiler() *Compiler { + return &Compiler{ + structTypeToCode: map[uintptr]*StructCode{}, + } +} + +func (c *Compiler) compile(typeptr uintptr) (*OpcodeSet, error) { + // noescape trick for header.typ ( reflect.*rtype ) + typ := *(**runtime.Type)(unsafe.Pointer(&typeptr)) + code, err := c.typeToCode(typ) + if err != nil { + return nil, err + } + return c.codeToOpcodeSet(typ, code) +} + +func (c *Compiler) codeToOpcodeSet(typ *runtime.Type, code Code) (*OpcodeSet, error) { + noescapeKeyCode := c.codeToOpcode(&compileContext{ + structTypeToCodes: map[uintptr]Opcodes{}, + recursiveCodes: &Opcodes{}, + }, typ, code) + if err := noescapeKeyCode.Validate(); err != nil { + return nil, err + } + escapeKeyCode := c.codeToOpcode(&compileContext{ + structTypeToCodes: map[uintptr]Opcodes{}, + recursiveCodes: &Opcodes{}, + escapeKey: true, + }, typ, code) + noescapeKeyCode = copyOpcode(noescapeKeyCode) + escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) + codeLength := noescapeKeyCode.TotalLength() + return &OpcodeSet{ + Type: typ, + NoescapeKeyCode: noescapeKeyCode, + EscapeKeyCode: escapeKeyCode, + InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode, + InterfaceEscapeKeyCode: interfaceEscapeKeyCode, + CodeLength: codeLength, + EndCode: ToEndCode(interfaceNoescapeKeyCode), + Code: code, + QueryCache: map[string]*OpcodeSet{}, + }, nil +} + +func (c *Compiler) typeToCode(typ *runtime.Type) (Code, error) { + switch { + case c.implementsMarshalJSON(typ): + return c.marshalJSONCode(typ) + case c.implementsMarshalText(typ): + return c.marshalTextCode(typ) + } + + isPtr := false + orgType := typ + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + isPtr = true + } + switch { + case c.implementsMarshalJSON(typ): + return c.marshalJSONCode(orgType) + case c.implementsMarshalText(typ): + return c.marshalTextCode(orgType) + } + switch typ.Kind() { + case reflect.Slice: + elem := typ.Elem() + if elem.Kind() == reflect.Uint8 { + p := runtime.PtrTo(elem) + if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) { + return c.bytesCode(typ, isPtr) + } + } + return c.sliceCode(typ) + case reflect.Map: + if isPtr { + return c.ptrCode(runtime.PtrTo(typ)) + } + return c.mapCode(typ) + case reflect.Struct: + return c.structCode(typ, isPtr) + case reflect.Int: + return c.intCode(typ, isPtr) + case reflect.Int8: + return c.int8Code(typ, isPtr) + case reflect.Int16: + return c.int16Code(typ, isPtr) + case reflect.Int32: + return c.int32Code(typ, isPtr) + case reflect.Int64: + return c.int64Code(typ, isPtr) + case reflect.Uint, reflect.Uintptr: + return c.uintCode(typ, isPtr) + case reflect.Uint8: + return c.uint8Code(typ, isPtr) + case reflect.Uint16: + return c.uint16Code(typ, isPtr) + case reflect.Uint32: + return c.uint32Code(typ, isPtr) + case reflect.Uint64: + return c.uint64Code(typ, isPtr) + case reflect.Float32: + return c.float32Code(typ, isPtr) + case reflect.Float64: + return c.float64Code(typ, isPtr) + case reflect.String: + return c.stringCode(typ, isPtr) + case reflect.Bool: + return c.boolCode(typ, isPtr) + case reflect.Interface: + return c.interfaceCode(typ, isPtr) + default: + if isPtr && typ.Implements(marshalTextType) { + typ = orgType + } + return c.typeToCodeWithPtr(typ, isPtr) + } +} + +func (c *Compiler) typeToCodeWithPtr(typ *runtime.Type, isPtr bool) (Code, error) { + switch { + case c.implementsMarshalJSON(typ): + return c.marshalJSONCode(typ) + case c.implementsMarshalText(typ): + return c.marshalTextCode(typ) + } + switch typ.Kind() { + case reflect.Ptr: + return c.ptrCode(typ) + case reflect.Slice: + elem := typ.Elem() + if elem.Kind() == reflect.Uint8 { + p := runtime.PtrTo(elem) + if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) { + return c.bytesCode(typ, false) + } + } + return c.sliceCode(typ) + case reflect.Array: + return c.arrayCode(typ) + case reflect.Map: + return c.mapCode(typ) + case reflect.Struct: + return c.structCode(typ, isPtr) + case reflect.Interface: + return c.interfaceCode(typ, false) + case reflect.Int: + return c.intCode(typ, false) + case reflect.Int8: + return c.int8Code(typ, false) + case reflect.Int16: + return c.int16Code(typ, false) + case reflect.Int32: + return c.int32Code(typ, false) + case reflect.Int64: + return c.int64Code(typ, false) + case reflect.Uint: + return c.uintCode(typ, false) + case reflect.Uint8: + return c.uint8Code(typ, false) + case reflect.Uint16: + return c.uint16Code(typ, false) + case reflect.Uint32: + return c.uint32Code(typ, false) + case reflect.Uint64: + return c.uint64Code(typ, false) + case reflect.Uintptr: + return c.uintCode(typ, false) + case reflect.Float32: + return c.float32Code(typ, false) + case reflect.Float64: + return c.float64Code(typ, false) + case reflect.String: + return c.stringCode(typ, false) + case reflect.Bool: + return c.boolCode(typ, false) + } + return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)} +} + +const intSize = 32 << (^uint(0) >> 63) + +//nolint:unparam +func (c *Compiler) intCode(typ *runtime.Type, isPtr bool) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) int8Code(typ *runtime.Type, isPtr bool) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) int16Code(typ *runtime.Type, isPtr bool) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) int32Code(typ *runtime.Type, isPtr bool) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) int64Code(typ *runtime.Type, isPtr bool) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) uintCode(typ *runtime.Type, isPtr bool) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) uint8Code(typ *runtime.Type, isPtr bool) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) uint16Code(typ *runtime.Type, isPtr bool) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) uint32Code(typ *runtime.Type, isPtr bool) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) uint64Code(typ *runtime.Type, isPtr bool) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) float32Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) { + return &FloatCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) float64Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) { + return &FloatCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) stringCode(typ *runtime.Type, isPtr bool) (*StringCode, error) { + return &StringCode{typ: typ, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) boolCode(typ *runtime.Type, isPtr bool) (*BoolCode, error) { + return &BoolCode{typ: typ, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) intStringCode(typ *runtime.Type) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: intSize, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) int8StringCode(typ *runtime.Type) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 8, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) int16StringCode(typ *runtime.Type) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 16, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) int32StringCode(typ *runtime.Type) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 32, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) int64StringCode(typ *runtime.Type) (*IntCode, error) { + return &IntCode{typ: typ, bitSize: 64, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) uintStringCode(typ *runtime.Type) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: intSize, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) uint8StringCode(typ *runtime.Type) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 8, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) uint16StringCode(typ *runtime.Type) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 16, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) uint32StringCode(typ *runtime.Type) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 32, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) uint64StringCode(typ *runtime.Type) (*UintCode, error) { + return &UintCode{typ: typ, bitSize: 64, isString: true}, nil +} + +//nolint:unparam +func (c *Compiler) bytesCode(typ *runtime.Type, isPtr bool) (*BytesCode, error) { + return &BytesCode{typ: typ, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) interfaceCode(typ *runtime.Type, isPtr bool) (*InterfaceCode, error) { + return &InterfaceCode{typ: typ, isPtr: isPtr}, nil +} + +//nolint:unparam +func (c *Compiler) marshalJSONCode(typ *runtime.Type) (*MarshalJSONCode, error) { + return &MarshalJSONCode{ + typ: typ, + isAddrForMarshaler: c.isPtrMarshalJSONType(typ), + isNilableType: c.isNilableType(typ), + isMarshalerContext: typ.Implements(marshalJSONContextType) || runtime.PtrTo(typ).Implements(marshalJSONContextType), + }, nil +} + +//nolint:unparam +func (c *Compiler) marshalTextCode(typ *runtime.Type) (*MarshalTextCode, error) { + return &MarshalTextCode{ + typ: typ, + isAddrForMarshaler: c.isPtrMarshalTextType(typ), + isNilableType: c.isNilableType(typ), + }, nil +} + +func (c *Compiler) ptrCode(typ *runtime.Type) (*PtrCode, error) { + code, err := c.typeToCodeWithPtr(typ.Elem(), true) + if err != nil { + return nil, err + } + ptr, ok := code.(*PtrCode) + if ok { + return &PtrCode{typ: typ, value: ptr.value, ptrNum: ptr.ptrNum + 1}, nil + } + return &PtrCode{typ: typ, value: code, ptrNum: 1}, nil +} + +func (c *Compiler) sliceCode(typ *runtime.Type) (*SliceCode, error) { + elem := typ.Elem() + code, err := c.listElemCode(elem) + if err != nil { + return nil, err + } + if code.Kind() == CodeKindStruct { + structCode := code.(*StructCode) + structCode.enableIndirect() + } + return &SliceCode{typ: typ, value: code}, nil +} + +func (c *Compiler) arrayCode(typ *runtime.Type) (*ArrayCode, error) { + elem := typ.Elem() + code, err := c.listElemCode(elem) + if err != nil { + return nil, err + } + if code.Kind() == CodeKindStruct { + structCode := code.(*StructCode) + structCode.enableIndirect() + } + return &ArrayCode{typ: typ, value: code}, nil +} + +func (c *Compiler) mapCode(typ *runtime.Type) (*MapCode, error) { + keyCode, err := c.mapKeyCode(typ.Key()) + if err != nil { + return nil, err + } + valueCode, err := c.mapValueCode(typ.Elem()) + if err != nil { + return nil, err + } + if valueCode.Kind() == CodeKindStruct { + structCode := valueCode.(*StructCode) + structCode.enableIndirect() + } + return &MapCode{typ: typ, key: keyCode, value: valueCode}, nil +} + +func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) { + switch { + case c.implementsMarshalJSONType(typ) || c.implementsMarshalJSONType(runtime.PtrTo(typ)): + return c.marshalJSONCode(typ) + case !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType): + return c.marshalTextCode(typ) + case typ.Kind() == reflect.Map: + return c.ptrCode(runtime.PtrTo(typ)) + default: + // isPtr was originally used to indicate whether the type of top level is pointer. + // However, since the slice/array element is a specification that can get the pointer address, explicitly set isPtr to true. + // See here for related issues: https://github.com/goccy/go-json/issues/370 + code, err := c.typeToCodeWithPtr(typ, true) + if err != nil { + return nil, err + } + ptr, ok := code.(*PtrCode) + if ok { + if ptr.value.Kind() == CodeKindMap { + ptr.ptrNum++ + } + } + return code, nil + } +} + +func (c *Compiler) mapKeyCode(typ *runtime.Type) (Code, error) { + switch { + case c.implementsMarshalText(typ): + return c.marshalTextCode(typ) + } + switch typ.Kind() { + case reflect.Ptr: + return c.ptrCode(typ) + case reflect.String: + return c.stringCode(typ, false) + case reflect.Int: + return c.intStringCode(typ) + case reflect.Int8: + return c.int8StringCode(typ) + case reflect.Int16: + return c.int16StringCode(typ) + case reflect.Int32: + return c.int32StringCode(typ) + case reflect.Int64: + return c.int64StringCode(typ) + case reflect.Uint: + return c.uintStringCode(typ) + case reflect.Uint8: + return c.uint8StringCode(typ) + case reflect.Uint16: + return c.uint16StringCode(typ) + case reflect.Uint32: + return c.uint32StringCode(typ) + case reflect.Uint64: + return c.uint64StringCode(typ) + case reflect.Uintptr: + return c.uintStringCode(typ) + } + return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)} +} + +func (c *Compiler) mapValueCode(typ *runtime.Type) (Code, error) { + switch typ.Kind() { + case reflect.Map: + return c.ptrCode(runtime.PtrTo(typ)) + default: + code, err := c.typeToCodeWithPtr(typ, false) + if err != nil { + return nil, err + } + ptr, ok := code.(*PtrCode) + if ok { + if ptr.value.Kind() == CodeKindMap { + ptr.ptrNum++ + } + } + return code, nil + } +} + +func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error) { + typeptr := uintptr(unsafe.Pointer(typ)) + if code, exists := c.structTypeToCode[typeptr]; exists { + derefCode := *code + derefCode.isRecursive = true + return &derefCode, nil + } + indirect := runtime.IfaceIndir(typ) + code := &StructCode{typ: typ, isPtr: isPtr, isIndirect: indirect} + c.structTypeToCode[typeptr] = code + + fieldNum := typ.NumField() + tags := c.typeToStructTags(typ) + fields := []*StructFieldCode{} + for i, tag := range tags { + isOnlyOneFirstField := i == 0 && fieldNum == 1 + field, err := c.structFieldCode(code, tag, isPtr, isOnlyOneFirstField) + if err != nil { + return nil, err + } + if field.isAnonymous { + structCode := field.getAnonymousStruct() + if structCode != nil { + structCode.removeFieldsByTags(tags) + if c.isAssignableIndirect(field, isPtr) { + if indirect { + structCode.isIndirect = true + } else { + structCode.isIndirect = false + } + } + } + } else { + structCode := field.getStruct() + if structCode != nil { + if indirect { + // if parent is indirect type, set child indirect property to true + structCode.isIndirect = true + } else { + // if parent is not indirect type, set child indirect property to false. + // but if parent's indirect is false and isPtr is true, then indirect must be true. + // Do this only if indirectConversion is enabled at the end of compileStruct. + structCode.isIndirect = false + } + } + } + fields = append(fields, field) + } + fieldMap := c.getFieldMap(fields) + duplicatedFieldMap := c.getDuplicatedFieldMap(fieldMap) + code.fields = c.filteredDuplicatedFields(fields, duplicatedFieldMap) + if !code.disableIndirectConversion && !indirect && isPtr { + code.enableIndirect() + } + delete(c.structTypeToCode, typeptr) + return code, nil +} + +func toElemType(t *runtime.Type) *runtime.Type { + for t.Kind() == reflect.Ptr { + t = t.Elem() + } + return t +} + +func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) { + field := tag.Field + fieldType := runtime.Type2RType(field.Type) + isIndirectSpecialCase := isPtr && isOnlyOneFirstField + fieldCode := &StructFieldCode{ + typ: fieldType, + key: tag.Key, + tag: tag, + offset: field.Offset, + isAnonymous: field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct, + isTaggedKey: tag.IsTaggedKey, + isNilableType: c.isNilableType(fieldType), + isNilCheck: true, + } + switch { + case c.isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(fieldType, isIndirectSpecialCase): + code, err := c.marshalJSONCode(fieldType) + if err != nil { + return nil, err + } + fieldCode.value = code + fieldCode.isAddrForMarshaler = true + fieldCode.isNilCheck = false + structCode.isIndirect = false + structCode.disableIndirectConversion = true + case c.isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(fieldType, isIndirectSpecialCase): + code, err := c.marshalTextCode(fieldType) + if err != nil { + return nil, err + } + fieldCode.value = code + fieldCode.isAddrForMarshaler = true + fieldCode.isNilCheck = false + structCode.isIndirect = false + structCode.disableIndirectConversion = true + case isPtr && c.isPtrMarshalJSONType(fieldType): + // *struct{ field T } + // func (*T) MarshalJSON() ([]byte, error) + code, err := c.marshalJSONCode(fieldType) + if err != nil { + return nil, err + } + fieldCode.value = code + fieldCode.isAddrForMarshaler = true + fieldCode.isNilCheck = false + case isPtr && c.isPtrMarshalTextType(fieldType): + // *struct{ field T } + // func (*T) MarshalText() ([]byte, error) + code, err := c.marshalTextCode(fieldType) + if err != nil { + return nil, err + } + fieldCode.value = code + fieldCode.isAddrForMarshaler = true + fieldCode.isNilCheck = false + default: + code, err := c.typeToCodeWithPtr(fieldType, isPtr) + if err != nil { + return nil, err + } + switch code.Kind() { + case CodeKindPtr, CodeKindInterface: + fieldCode.isNextOpPtrType = true + } + fieldCode.value = code + } + return fieldCode, nil +} + +func (c *Compiler) isAssignableIndirect(fieldCode *StructFieldCode, isPtr bool) bool { + if isPtr { + return false + } + codeType := fieldCode.value.Kind() + if codeType == CodeKindMarshalJSON { + return false + } + if codeType == CodeKindMarshalText { + return false + } + return true +} + +func (c *Compiler) getFieldMap(fields []*StructFieldCode) map[string][]*StructFieldCode { + fieldMap := map[string][]*StructFieldCode{} + for _, field := range fields { + if field.isAnonymous { + for k, v := range c.getAnonymousFieldMap(field) { + fieldMap[k] = append(fieldMap[k], v...) + } + continue + } + fieldMap[field.key] = append(fieldMap[field.key], field) + } + return fieldMap +} + +func (c *Compiler) getAnonymousFieldMap(field *StructFieldCode) map[string][]*StructFieldCode { + fieldMap := map[string][]*StructFieldCode{} + structCode := field.getAnonymousStruct() + if structCode == nil || structCode.isRecursive { + fieldMap[field.key] = append(fieldMap[field.key], field) + return fieldMap + } + for k, v := range c.getFieldMapFromAnonymousParent(structCode.fields) { + fieldMap[k] = append(fieldMap[k], v...) + } + return fieldMap +} + +func (c *Compiler) getFieldMapFromAnonymousParent(fields []*StructFieldCode) map[string][]*StructFieldCode { + fieldMap := map[string][]*StructFieldCode{} + for _, field := range fields { + if field.isAnonymous { + for k, v := range c.getAnonymousFieldMap(field) { + // Do not handle tagged key when embedding more than once + for _, vv := range v { + vv.isTaggedKey = false + } + fieldMap[k] = append(fieldMap[k], v...) + } + continue + } + fieldMap[field.key] = append(fieldMap[field.key], field) + } + return fieldMap +} + +func (c *Compiler) getDuplicatedFieldMap(fieldMap map[string][]*StructFieldCode) map[*StructFieldCode]struct{} { + duplicatedFieldMap := map[*StructFieldCode]struct{}{} + for _, fields := range fieldMap { + if len(fields) == 1 { + continue + } + if c.isTaggedKeyOnly(fields) { + for _, field := range fields { + if field.isTaggedKey { + continue + } + duplicatedFieldMap[field] = struct{}{} + } + } else { + for _, field := range fields { + duplicatedFieldMap[field] = struct{}{} + } + } + } + return duplicatedFieldMap +} + +func (c *Compiler) filteredDuplicatedFields(fields []*StructFieldCode, duplicatedFieldMap map[*StructFieldCode]struct{}) []*StructFieldCode { + filteredFields := make([]*StructFieldCode, 0, len(fields)) + for _, field := range fields { + if field.isAnonymous { + structCode := field.getAnonymousStruct() + if structCode != nil && !structCode.isRecursive { + structCode.fields = c.filteredDuplicatedFields(structCode.fields, duplicatedFieldMap) + if len(structCode.fields) > 0 { + filteredFields = append(filteredFields, field) + } + continue + } + } + if _, exists := duplicatedFieldMap[field]; exists { + continue + } + filteredFields = append(filteredFields, field) + } + return filteredFields +} + +func (c *Compiler) isTaggedKeyOnly(fields []*StructFieldCode) bool { + var taggedKeyFieldCount int + for _, field := range fields { + if field.isTaggedKey { + taggedKeyFieldCount++ + } + } + return taggedKeyFieldCount == 1 +} + +func (c *Compiler) typeToStructTags(typ *runtime.Type) runtime.StructTags { + tags := runtime.StructTags{} + fieldNum := typ.NumField() + for i := 0; i < fieldNum; i++ { + field := typ.Field(i) + if runtime.IsIgnoredStructField(field) { + continue + } + tags = append(tags, runtime.StructTagFromField(field)) + } + return tags +} + +// *struct{ field T } => struct { field *T } +// func (*T) MarshalJSON() ([]byte, error) +func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool { + return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalJSONType(typ) +} + +// *struct{ field T } => struct { field *T } +// func (*T) MarshalText() ([]byte, error) +func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool { + return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalTextType(typ) +} + +func (c *Compiler) implementsMarshalJSON(typ *runtime.Type) bool { + if !c.implementsMarshalJSONType(typ) { + return false + } + if typ.Kind() != reflect.Ptr { + return true + } + // type kind is reflect.Ptr + if !c.implementsMarshalJSONType(typ.Elem()) { + return true + } + // needs to dereference + return false +} + +func (c *Compiler) implementsMarshalText(typ *runtime.Type) bool { + if !typ.Implements(marshalTextType) { + return false + } + if typ.Kind() != reflect.Ptr { + return true + } + // type kind is reflect.Ptr + if !typ.Elem().Implements(marshalTextType) { + return true + } + // needs to dereference + return false +} + +func (c *Compiler) isNilableType(typ *runtime.Type) bool { + if !runtime.IfaceIndir(typ) { + return true + } + switch typ.Kind() { + case reflect.Ptr: + return true + case reflect.Map: + return true + case reflect.Func: + return true + default: + return false + } +} + +func (c *Compiler) implementsMarshalJSONType(typ *runtime.Type) bool { + return typ.Implements(marshalJSONType) || typ.Implements(marshalJSONContextType) +} + +func (c *Compiler) isPtrMarshalJSONType(typ *runtime.Type) bool { + return !c.implementsMarshalJSONType(typ) && c.implementsMarshalJSONType(runtime.PtrTo(typ)) +} + +func (c *Compiler) isPtrMarshalTextType(typ *runtime.Type) bool { + return !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType) +} + +func (c *Compiler) codeToOpcode(ctx *compileContext, typ *runtime.Type, code Code) *Opcode { + codes := code.ToOpcode(ctx) + codes.Last().Next = newEndOp(ctx, typ) + c.linkRecursiveCode(ctx) + return codes.First() +} + +func (c *Compiler) linkRecursiveCode(ctx *compileContext) { + recursiveCodes := map[uintptr]*CompiledCode{} + for _, recursive := range *ctx.recursiveCodes { + typeptr := uintptr(unsafe.Pointer(recursive.Type)) + codes := ctx.structTypeToCodes[typeptr] + if recursiveCode, ok := recursiveCodes[typeptr]; ok { + *recursive.Jmp = *recursiveCode + continue + } + + code := copyOpcode(codes.First()) + code.Op = code.Op.PtrHeadToHead() + lastCode := newEndOp(&compileContext{}, recursive.Type) + lastCode.Op = OpRecursiveEnd + + // OpRecursiveEnd must set before call TotalLength + code.End.Next = lastCode + + totalLength := code.TotalLength() + + // Idx, ElemIdx, Length must set after call TotalLength + lastCode.Idx = uint32((totalLength + 1) * uintptrSize) + lastCode.ElemIdx = lastCode.Idx + uintptrSize + lastCode.Length = lastCode.Idx + 2*uintptrSize + + // extend length to alloc slot for elemIdx + length + curTotalLength := uintptr(recursive.TotalLength()) + 3 + nextTotalLength := uintptr(totalLength) + 3 + + compiled := recursive.Jmp + compiled.Code = code + compiled.CurLen = curTotalLength + compiled.NextLen = nextTotalLength + compiled.Linked = true + + recursiveCodes[typeptr] = compiled + } +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go new file mode 100644 index 00000000..b6f45a49 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go @@ -0,0 +1,33 @@ +//go:build !race +// +build !race + +package encoder + +func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) { + initEncoder() + if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr { + codeSet, err := compileToGetCodeSetSlowPath(typeptr) + if err != nil { + return nil, err + } + return getFilteredCodeSetIfNeeded(ctx, codeSet) + } + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + if codeSet := cachedOpcodeSets[index]; codeSet != nil { + filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet) + if err != nil { + return nil, err + } + return filtered, nil + } + codeSet, err := newCompiler().compile(typeptr) + if err != nil { + return nil, err + } + filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet) + if err != nil { + return nil, err + } + cachedOpcodeSets[index] = codeSet + return filtered, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go new file mode 100644 index 00000000..47b482f7 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go @@ -0,0 +1,46 @@ +//go:build race +// +build race + +package encoder + +import ( + "sync" +) + +var setsMu sync.RWMutex + +func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) { + initEncoder() + if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr { + codeSet, err := compileToGetCodeSetSlowPath(typeptr) + if err != nil { + return nil, err + } + return getFilteredCodeSetIfNeeded(ctx, codeSet) + } + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + setsMu.RLock() + if codeSet := cachedOpcodeSets[index]; codeSet != nil { + filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet) + if err != nil { + setsMu.RUnlock() + return nil, err + } + setsMu.RUnlock() + return filtered, nil + } + setsMu.RUnlock() + + codeSet, err := newCompiler().compile(typeptr) + if err != nil { + return nil, err + } + filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet) + if err != nil { + return nil, err + } + setsMu.Lock() + cachedOpcodeSets[index] = codeSet + setsMu.Unlock() + return filtered, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/context.go b/vendor/github.com/goccy/go-json/internal/encoder/context.go new file mode 100644 index 00000000..3833d0c8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/context.go @@ -0,0 +1,105 @@ +package encoder + +import ( + "context" + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type compileContext struct { + opcodeIndex uint32 + ptrIndex int + indent uint32 + escapeKey bool + structTypeToCodes map[uintptr]Opcodes + recursiveCodes *Opcodes +} + +func (c *compileContext) incIndent() { + c.indent++ +} + +func (c *compileContext) decIndent() { + c.indent-- +} + +func (c *compileContext) incIndex() { + c.incOpcodeIndex() + c.incPtrIndex() +} + +func (c *compileContext) decIndex() { + c.decOpcodeIndex() + c.decPtrIndex() +} + +func (c *compileContext) incOpcodeIndex() { + c.opcodeIndex++ +} + +func (c *compileContext) decOpcodeIndex() { + c.opcodeIndex-- +} + +func (c *compileContext) incPtrIndex() { + c.ptrIndex++ +} + +func (c *compileContext) decPtrIndex() { + c.ptrIndex-- +} + +const ( + bufSize = 1024 +) + +var ( + runtimeContextPool = sync.Pool{ + New: func() interface{} { + return &RuntimeContext{ + Buf: make([]byte, 0, bufSize), + Ptrs: make([]uintptr, 128), + KeepRefs: make([]unsafe.Pointer, 0, 8), + Option: &Option{}, + } + }, + } +) + +type RuntimeContext struct { + Context context.Context + Buf []byte + MarshalBuf []byte + Ptrs []uintptr + KeepRefs []unsafe.Pointer + SeenPtr []uintptr + BaseIndent uint32 + Prefix []byte + IndentStr []byte + Option *Option +} + +func (c *RuntimeContext) Init(p uintptr, codelen int) { + if len(c.Ptrs) < codelen { + c.Ptrs = make([]uintptr, codelen) + } + c.Ptrs[0] = p + c.KeepRefs = c.KeepRefs[:0] + c.SeenPtr = c.SeenPtr[:0] + c.BaseIndent = 0 +} + +func (c *RuntimeContext) Ptr() uintptr { + header := (*runtime.SliceHeader)(unsafe.Pointer(&c.Ptrs)) + return uintptr(header.Data) +} + +func TakeRuntimeContext() *RuntimeContext { + return runtimeContextPool.Get().(*RuntimeContext) +} + +func ReleaseRuntimeContext(ctx *RuntimeContext) { + runtimeContextPool.Put(ctx) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go new file mode 100644 index 00000000..35c959d4 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go @@ -0,0 +1,126 @@ +package encoder + +import "unicode/utf8" + +const ( + // The default lowest and highest continuation byte. + locb = 128 //0b10000000 + hicb = 191 //0b10111111 + + // These names of these constants are chosen to give nice alignment in the + // table below. The first nibble is an index into acceptRanges or F for + // special one-byte cases. The second nibble is the Rune length or the + // Status for the special one-byte case. + xx = 0xF1 // invalid: size 1 + as = 0xF0 // ASCII: size 1 + s1 = 0x02 // accept 0, size 2 + s2 = 0x13 // accept 1, size 3 + s3 = 0x03 // accept 0, size 3 + s4 = 0x23 // accept 2, size 3 + s5 = 0x34 // accept 3, size 4 + s6 = 0x04 // accept 0, size 4 + s7 = 0x44 // accept 4, size 4 +) + +// first is information about the first byte in a UTF-8 sequence. +var first = [256]uint8{ + // 1 2 3 4 5 6 7 8 9 A B C D E F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F + as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F + // 1 2 3 4 5 6 7 8 9 A B C D E F + xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F + xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F + xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF + xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF + xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF + s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF + s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF + s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF +} + +const ( + lineSep = byte(168) //'\u2028' + paragraphSep = byte(169) //'\u2029' +) + +type decodeRuneState int + +const ( + validUTF8State decodeRuneState = iota + runeErrorState + lineSepState + paragraphSepState +) + +func decodeRuneInString(s string) (decodeRuneState, int) { + n := len(s) + s0 := s[0] + x := first[s0] + if x >= as { + // The following code simulates an additional check for x == xx and + // handling the ASCII and invalid cases accordingly. This mask-and-or + // approach prevents an additional branch. + mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF. + if rune(s[0])&^mask|utf8.RuneError&mask == utf8.RuneError { + return runeErrorState, 1 + } + return validUTF8State, 1 + } + sz := int(x & 7) + if n < sz { + return runeErrorState, 1 + } + s1 := s[1] + switch x >> 4 { + case 0: + if s1 < locb || hicb < s1 { + return runeErrorState, 1 + } + case 1: + if s1 < 0xA0 || hicb < s1 { + return runeErrorState, 1 + } + case 2: + if s1 < locb || 0x9F < s1 { + return runeErrorState, 1 + } + case 3: + if s1 < 0x90 || hicb < s1 { + return runeErrorState, 1 + } + case 4: + if s1 < locb || 0x8F < s1 { + return runeErrorState, 1 + } + } + if sz <= 2 { + return validUTF8State, 2 + } + s2 := s[2] + if s2 < locb || hicb < s2 { + return runeErrorState, 1 + } + if sz <= 3 { + // separator character prefixes: [2]byte{226, 128} + if s0 == 226 && s1 == 128 { + switch s2 { + case lineSep: + return lineSepState, 3 + case paragraphSep: + return paragraphSepState, 3 + } + } + return validUTF8State, 3 + } + s3 := s[3] + if s3 < locb || hicb < s3 { + return runeErrorState, 1 + } + return validUTF8State, 4 +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go new file mode 100644 index 00000000..b436f5b2 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go @@ -0,0 +1,601 @@ +package encoder + +import ( + "bytes" + "encoding" + "encoding/base64" + "encoding/json" + "fmt" + "math" + "reflect" + "strconv" + "strings" + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +func (t OpType) IsMultipleOpHead() bool { + switch t { + case OpStructHead: + return true + case OpStructHeadSlice: + return true + case OpStructHeadArray: + return true + case OpStructHeadMap: + return true + case OpStructHeadStruct: + return true + case OpStructHeadOmitEmpty: + return true + case OpStructHeadOmitEmptySlice: + return true + case OpStructHeadOmitEmptyArray: + return true + case OpStructHeadOmitEmptyMap: + return true + case OpStructHeadOmitEmptyStruct: + return true + case OpStructHeadSlicePtr: + return true + case OpStructHeadOmitEmptySlicePtr: + return true + case OpStructHeadArrayPtr: + return true + case OpStructHeadOmitEmptyArrayPtr: + return true + case OpStructHeadMapPtr: + return true + case OpStructHeadOmitEmptyMapPtr: + return true + } + return false +} + +func (t OpType) IsMultipleOpField() bool { + switch t { + case OpStructField: + return true + case OpStructFieldSlice: + return true + case OpStructFieldArray: + return true + case OpStructFieldMap: + return true + case OpStructFieldStruct: + return true + case OpStructFieldOmitEmpty: + return true + case OpStructFieldOmitEmptySlice: + return true + case OpStructFieldOmitEmptyArray: + return true + case OpStructFieldOmitEmptyMap: + return true + case OpStructFieldOmitEmptyStruct: + return true + case OpStructFieldSlicePtr: + return true + case OpStructFieldOmitEmptySlicePtr: + return true + case OpStructFieldArrayPtr: + return true + case OpStructFieldOmitEmptyArrayPtr: + return true + case OpStructFieldMapPtr: + return true + case OpStructFieldOmitEmptyMapPtr: + return true + } + return false +} + +type OpcodeSet struct { + Type *runtime.Type + NoescapeKeyCode *Opcode + EscapeKeyCode *Opcode + InterfaceNoescapeKeyCode *Opcode + InterfaceEscapeKeyCode *Opcode + CodeLength int + EndCode *Opcode + Code Code + QueryCache map[string]*OpcodeSet + cacheMu sync.RWMutex +} + +func (s *OpcodeSet) getQueryCache(hash string) *OpcodeSet { + s.cacheMu.RLock() + codeSet := s.QueryCache[hash] + s.cacheMu.RUnlock() + return codeSet +} + +func (s *OpcodeSet) setQueryCache(hash string, codeSet *OpcodeSet) { + s.cacheMu.Lock() + s.QueryCache[hash] = codeSet + s.cacheMu.Unlock() +} + +type CompiledCode struct { + Code *Opcode + Linked bool // whether recursive code already have linked + CurLen uintptr + NextLen uintptr +} + +const StartDetectingCyclesAfter = 1000 + +func Load(base uintptr, idx uintptr) uintptr { + addr := base + idx + return **(**uintptr)(unsafe.Pointer(&addr)) +} + +func Store(base uintptr, idx uintptr, p uintptr) { + addr := base + idx + **(**uintptr)(unsafe.Pointer(&addr)) = p +} + +func LoadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr { + addr := base + idx + p := **(**uintptr)(unsafe.Pointer(&addr)) + if p == 0 { + return 0 + } + return PtrToPtr(p) + /* + for i := 0; i < ptrNum; i++ { + if p == 0 { + return p + } + p = PtrToPtr(p) + } + return p + */ +} + +func PtrToUint64(p uintptr) uint64 { return **(**uint64)(unsafe.Pointer(&p)) } +func PtrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) } +func PtrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) } +func PtrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) } +func PtrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) } +func PtrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) } +func PtrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) } +func PtrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) } +func PtrToPtr(p uintptr) uintptr { + return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p))) +} +func PtrToNPtr(p uintptr, ptrNum int) uintptr { + for i := 0; i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = PtrToPtr(p) + } + return p +} + +func PtrToUnsafePtr(p uintptr) unsafe.Pointer { + return *(*unsafe.Pointer)(unsafe.Pointer(&p)) +} +func PtrToInterface(code *Opcode, p uintptr) interface{} { + return *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) +} + +func ErrUnsupportedValue(code *Opcode, ptr uintptr) *errors.UnsupportedValueError { + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&ptr)), + })) + return &errors.UnsupportedValueError{ + Value: reflect.ValueOf(v), + Str: fmt.Sprintf("encountered a cycle via %s", code.Type), + } +} + +func ErrUnsupportedFloat(v float64) *errors.UnsupportedValueError { + return &errors.UnsupportedValueError{ + Value: reflect.ValueOf(v), + Str: strconv.FormatFloat(v, 'g', -1, 64), + } +} + +func ErrMarshalerWithCode(code *Opcode, err error) *errors.MarshalerError { + return &errors.MarshalerError{ + Type: runtime.RType2Type(code.Type), + Err: err, + } +} + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +type MapItem struct { + Key []byte + Value []byte +} + +type Mapslice struct { + Items []MapItem +} + +func (m *Mapslice) Len() int { + return len(m.Items) +} + +func (m *Mapslice) Less(i, j int) bool { + return bytes.Compare(m.Items[i].Key, m.Items[j].Key) < 0 +} + +func (m *Mapslice) Swap(i, j int) { + m.Items[i], m.Items[j] = m.Items[j], m.Items[i] +} + +//nolint:structcheck,unused +type mapIter struct { + key unsafe.Pointer + elem unsafe.Pointer + t unsafe.Pointer + h unsafe.Pointer + buckets unsafe.Pointer + bptr unsafe.Pointer + overflow unsafe.Pointer + oldoverflow unsafe.Pointer + startBucket uintptr + offset uint8 + wrapped bool + B uint8 + i uint8 + bucket uintptr + checkBucket uintptr +} + +type MapContext struct { + Start int + First int + Idx int + Slice *Mapslice + Buf []byte + Len int + Iter mapIter +} + +var mapContextPool = sync.Pool{ + New: func() interface{} { + return &MapContext{ + Slice: &Mapslice{}, + } + }, +} + +func NewMapContext(mapLen int, unorderedMap bool) *MapContext { + ctx := mapContextPool.Get().(*MapContext) + if !unorderedMap { + if len(ctx.Slice.Items) < mapLen { + ctx.Slice.Items = make([]MapItem, mapLen) + } else { + ctx.Slice.Items = ctx.Slice.Items[:mapLen] + } + } + ctx.Buf = ctx.Buf[:0] + ctx.Iter = mapIter{} + ctx.Idx = 0 + ctx.Len = mapLen + return ctx +} + +func ReleaseMapContext(c *MapContext) { + mapContextPool.Put(c) +} + +//go:linkname MapIterInit runtime.mapiterinit +//go:noescape +func MapIterInit(mapType *runtime.Type, m unsafe.Pointer, it *mapIter) + +//go:linkname MapIterKey reflect.mapiterkey +//go:noescape +func MapIterKey(it *mapIter) unsafe.Pointer + +//go:linkname MapIterNext reflect.mapiternext +//go:noescape +func MapIterNext(it *mapIter) + +//go:linkname MapLen reflect.maplen +//go:noescape +func MapLen(m unsafe.Pointer) int + +func AppendByteSlice(_ *RuntimeContext, b []byte, src []byte) []byte { + if src == nil { + return append(b, `null`...) + } + encodedLen := base64.StdEncoding.EncodedLen(len(src)) + b = append(b, '"') + pos := len(b) + remainLen := cap(b[pos:]) + var buf []byte + if remainLen > encodedLen { + buf = b[pos : pos+encodedLen] + } else { + buf = make([]byte, encodedLen) + } + base64.StdEncoding.Encode(buf, src) + return append(append(b, buf...), '"') +} + +func AppendFloat32(_ *RuntimeContext, b []byte, v float32) []byte { + f64 := float64(v) + abs := math.Abs(f64) + fmt := byte('f') + // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right. + if abs != 0 { + f32 := float32(abs) + if f32 < 1e-6 || f32 >= 1e21 { + fmt = 'e' + } + } + return strconv.AppendFloat(b, f64, fmt, -1, 32) +} + +func AppendFloat64(_ *RuntimeContext, b []byte, v float64) []byte { + abs := math.Abs(v) + fmt := byte('f') + // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right. + if abs != 0 { + if abs < 1e-6 || abs >= 1e21 { + fmt = 'e' + } + } + return strconv.AppendFloat(b, v, fmt, -1, 64) +} + +func AppendBool(_ *RuntimeContext, b []byte, v bool) []byte { + if v { + return append(b, "true"...) + } + return append(b, "false"...) +} + +var ( + floatTable = [256]bool{ + '0': true, + '1': true, + '2': true, + '3': true, + '4': true, + '5': true, + '6': true, + '7': true, + '8': true, + '9': true, + '.': true, + 'e': true, + 'E': true, + '+': true, + '-': true, + } +) + +func AppendNumber(_ *RuntimeContext, b []byte, n json.Number) ([]byte, error) { + if len(n) == 0 { + return append(b, '0'), nil + } + for i := 0; i < len(n); i++ { + if !floatTable[n[i]] { + return nil, fmt.Errorf("json: invalid number literal %q", n) + } + } + b = append(b, n...) + return b, nil +} + +func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { + rv := reflect.ValueOf(v) // convert by dynamic interface type + if (code.Flags & AddrForMarshalerFlags) != 0 { + if rv.CanAddr() { + rv = rv.Addr() + } else { + newV := reflect.New(rv.Type()) + newV.Elem().Set(rv) + rv = newV + } + } + + if rv.Kind() == reflect.Ptr && rv.IsNil() { + return AppendNull(ctx, b), nil + } + + v = rv.Interface() + var bb []byte + if (code.Flags & MarshalerContextFlags) != 0 { + marshaler, ok := v.(marshalerContext) + if !ok { + return AppendNull(ctx, b), nil + } + stdctx := ctx.Option.Context + if ctx.Option.Flag&FieldQueryOption != 0 { + stdctx = SetFieldQueryToContext(stdctx, code.FieldQuery) + } + b, err := marshaler.MarshalJSON(stdctx) + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + bb = b + } else { + marshaler, ok := v.(json.Marshaler) + if !ok { + return AppendNull(ctx, b), nil + } + b, err := marshaler.MarshalJSON() + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + bb = b + } + marshalBuf := ctx.MarshalBuf[:0] + marshalBuf = append(append(marshalBuf, bb...), nul) + compactedBuf, err := compact(b, marshalBuf, (ctx.Option.Flag&HTMLEscapeOption) != 0) + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + ctx.MarshalBuf = marshalBuf + return compactedBuf, nil +} + +func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { + rv := reflect.ValueOf(v) // convert by dynamic interface type + if (code.Flags & AddrForMarshalerFlags) != 0 { + if rv.CanAddr() { + rv = rv.Addr() + } else { + newV := reflect.New(rv.Type()) + newV.Elem().Set(rv) + rv = newV + } + } + v = rv.Interface() + var bb []byte + if (code.Flags & MarshalerContextFlags) != 0 { + marshaler, ok := v.(marshalerContext) + if !ok { + return AppendNull(ctx, b), nil + } + b, err := marshaler.MarshalJSON(ctx.Option.Context) + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + bb = b + } else { + marshaler, ok := v.(json.Marshaler) + if !ok { + return AppendNull(ctx, b), nil + } + b, err := marshaler.MarshalJSON() + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + bb = b + } + marshalBuf := ctx.MarshalBuf[:0] + marshalBuf = append(append(marshalBuf, bb...), nul) + indentedBuf, err := doIndent( + b, + marshalBuf, + string(ctx.Prefix)+strings.Repeat(string(ctx.IndentStr), int(ctx.BaseIndent+code.Indent)), + string(ctx.IndentStr), + (ctx.Option.Flag&HTMLEscapeOption) != 0, + ) + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + ctx.MarshalBuf = marshalBuf + return indentedBuf, nil +} + +func AppendMarshalText(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { + rv := reflect.ValueOf(v) // convert by dynamic interface type + if (code.Flags & AddrForMarshalerFlags) != 0 { + if rv.CanAddr() { + rv = rv.Addr() + } else { + newV := reflect.New(rv.Type()) + newV.Elem().Set(rv) + rv = newV + } + } + v = rv.Interface() + marshaler, ok := v.(encoding.TextMarshaler) + if !ok { + return AppendNull(ctx, b), nil + } + bytes, err := marshaler.MarshalText() + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil +} + +func AppendMarshalTextIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { + rv := reflect.ValueOf(v) // convert by dynamic interface type + if (code.Flags & AddrForMarshalerFlags) != 0 { + if rv.CanAddr() { + rv = rv.Addr() + } else { + newV := reflect.New(rv.Type()) + newV.Elem().Set(rv) + rv = newV + } + } + v = rv.Interface() + marshaler, ok := v.(encoding.TextMarshaler) + if !ok { + return AppendNull(ctx, b), nil + } + bytes, err := marshaler.MarshalText() + if err != nil { + return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + } + return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil +} + +func AppendNull(_ *RuntimeContext, b []byte) []byte { + return append(b, "null"...) +} + +func AppendComma(_ *RuntimeContext, b []byte) []byte { + return append(b, ',') +} + +func AppendCommaIndent(_ *RuntimeContext, b []byte) []byte { + return append(b, ',', '\n') +} + +func AppendStructEnd(_ *RuntimeContext, b []byte) []byte { + return append(b, '}', ',') +} + +func AppendStructEndIndent(ctx *RuntimeContext, code *Opcode, b []byte) []byte { + b = append(b, '\n') + b = append(b, ctx.Prefix...) + indentNum := ctx.BaseIndent + code.Indent - 1 + for i := uint32(0); i < indentNum; i++ { + b = append(b, ctx.IndentStr...) + } + return append(b, '}', ',', '\n') +} + +func AppendIndent(ctx *RuntimeContext, b []byte, indent uint32) []byte { + b = append(b, ctx.Prefix...) + indentNum := ctx.BaseIndent + indent + for i := uint32(0); i < indentNum; i++ { + b = append(b, ctx.IndentStr...) + } + return b +} + +func IsNilForMarshaler(v interface{}) bool { + rv := reflect.ValueOf(v) + switch rv.Kind() { + case reflect.Bool: + return !rv.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return rv.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return rv.Uint() == 0 + case reflect.Float32, reflect.Float64: + return math.Float64bits(rv.Float()) == 0 + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Func: + return rv.IsNil() + case reflect.Slice: + return rv.IsNil() || rv.Len() == 0 + case reflect.String: + return rv.Len() == 0 + } + return false +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/indent.go b/vendor/github.com/goccy/go-json/internal/encoder/indent.go new file mode 100644 index 00000000..dfe04b5e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/indent.go @@ -0,0 +1,211 @@ +package encoder + +import ( + "bytes" + "fmt" + + "github.com/goccy/go-json/internal/errors" +) + +func takeIndentSrcRuntimeContext(src []byte) (*RuntimeContext, []byte) { + ctx := TakeRuntimeContext() + buf := ctx.Buf[:0] + buf = append(append(buf, src...), nul) + ctx.Buf = buf + return ctx, buf +} + +func Indent(buf *bytes.Buffer, src []byte, prefix, indentStr string) error { + if len(src) == 0 { + return errors.ErrUnexpectedEndOfJSON("", 0) + } + + srcCtx, srcBuf := takeIndentSrcRuntimeContext(src) + dstCtx := TakeRuntimeContext() + dst := dstCtx.Buf[:0] + + dst, err := indentAndWrite(buf, dst, srcBuf, prefix, indentStr) + if err != nil { + ReleaseRuntimeContext(srcCtx) + ReleaseRuntimeContext(dstCtx) + return err + } + dstCtx.Buf = dst + ReleaseRuntimeContext(srcCtx) + ReleaseRuntimeContext(dstCtx) + return nil +} + +func indentAndWrite(buf *bytes.Buffer, dst []byte, src []byte, prefix, indentStr string) ([]byte, error) { + dst, err := doIndent(dst, src, prefix, indentStr, false) + if err != nil { + return nil, err + } + if _, err := buf.Write(dst); err != nil { + return nil, err + } + return dst, nil +} + +func doIndent(dst, src []byte, prefix, indentStr string, escape bool) ([]byte, error) { + buf, cursor, err := indentValue(dst, src, 0, 0, []byte(prefix), []byte(indentStr), escape) + if err != nil { + return nil, err + } + if err := validateEndBuf(src, cursor); err != nil { + return nil, err + } + return buf, nil +} + +func indentValue( + dst []byte, + src []byte, + indentNum int, + cursor int64, + prefix []byte, + indentBytes []byte, + escape bool) ([]byte, int64, error) { + for { + switch src[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case '{': + return indentObject(dst, src, indentNum, cursor, prefix, indentBytes, escape) + case '}': + return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor) + case '[': + return indentArray(dst, src, indentNum, cursor, prefix, indentBytes, escape) + case ']': + return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor) + case '"': + return compactString(dst, src, cursor, escape) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return compactNumber(dst, src, cursor) + case 't': + return compactTrue(dst, src, cursor) + case 'f': + return compactFalse(dst, src, cursor) + case 'n': + return compactNull(dst, src, cursor) + default: + return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor) + } + } +} + +func indentObject( + dst []byte, + src []byte, + indentNum int, + cursor int64, + prefix []byte, + indentBytes []byte, + escape bool) ([]byte, int64, error) { + if src[cursor] == '{' { + dst = append(dst, '{') + } else { + return nil, 0, errors.ErrExpected("expected { character for object value", cursor) + } + cursor = skipWhiteSpace(src, cursor+1) + if src[cursor] == '}' { + dst = append(dst, '}') + return dst, cursor + 1, nil + } + indentNum++ + var err error + for { + dst = append(append(dst, '\n'), prefix...) + for i := 0; i < indentNum; i++ { + dst = append(dst, indentBytes...) + } + cursor = skipWhiteSpace(src, cursor) + dst, cursor, err = compactString(dst, src, cursor, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + if src[cursor] != ':' { + return nil, 0, errors.ErrSyntax( + fmt.Sprintf("invalid character '%c' after object key", src[cursor]), + cursor+1, + ) + } + dst = append(dst, ':', ' ') + dst, cursor, err = indentValue(dst, src, indentNum, cursor+1, prefix, indentBytes, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + switch src[cursor] { + case '}': + dst = append(append(dst, '\n'), prefix...) + for i := 0; i < indentNum-1; i++ { + dst = append(dst, indentBytes...) + } + dst = append(dst, '}') + cursor++ + return dst, cursor, nil + case ',': + dst = append(dst, ',') + default: + return nil, 0, errors.ErrSyntax( + fmt.Sprintf("invalid character '%c' after object key:value pair", src[cursor]), + cursor+1, + ) + } + cursor++ + } +} + +func indentArray( + dst []byte, + src []byte, + indentNum int, + cursor int64, + prefix []byte, + indentBytes []byte, + escape bool) ([]byte, int64, error) { + if src[cursor] == '[' { + dst = append(dst, '[') + } else { + return nil, 0, errors.ErrExpected("expected [ character for array value", cursor) + } + cursor = skipWhiteSpace(src, cursor+1) + if src[cursor] == ']' { + dst = append(dst, ']') + return dst, cursor + 1, nil + } + indentNum++ + var err error + for { + dst = append(append(dst, '\n'), prefix...) + for i := 0; i < indentNum; i++ { + dst = append(dst, indentBytes...) + } + dst, cursor, err = indentValue(dst, src, indentNum, cursor, prefix, indentBytes, escape) + if err != nil { + return nil, 0, err + } + cursor = skipWhiteSpace(src, cursor) + switch src[cursor] { + case ']': + dst = append(append(dst, '\n'), prefix...) + for i := 0; i < indentNum-1; i++ { + dst = append(dst, indentBytes...) + } + dst = append(dst, ']') + cursor++ + return dst, cursor, nil + case ',': + dst = append(dst, ',') + default: + return nil, 0, errors.ErrSyntax( + fmt.Sprintf("invalid character '%c' after array value", src[cursor]), + cursor+1, + ) + } + cursor++ + } +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/int.go b/vendor/github.com/goccy/go-json/internal/encoder/int.go new file mode 100644 index 00000000..8b5febea --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/int.go @@ -0,0 +1,176 @@ +// This files's processing codes are inspired by https://github.com/segmentio/encoding. +// The license notation is as follows. +// +// # MIT License +// +// Copyright (c) 2019 Segment.io, Inc. +// +// 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. +package encoder + +import ( + "unsafe" +) + +var endianness int + +func init() { + var b [2]byte + *(*uint16)(unsafe.Pointer(&b)) = uint16(0xABCD) + + switch b[0] { + case 0xCD: + endianness = 0 // LE + case 0xAB: + endianness = 1 // BE + default: + panic("could not determine endianness") + } +} + +// "00010203...96979899" cast to []uint16 +var intLELookup = [100]uint16{ + 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930, + 0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731, 0x3831, 0x3931, + 0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632, 0x3732, 0x3832, 0x3932, + 0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533, 0x3633, 0x3733, 0x3833, 0x3933, + 0x3034, 0x3134, 0x3234, 0x3334, 0x3434, 0x3534, 0x3634, 0x3734, 0x3834, 0x3934, + 0x3035, 0x3135, 0x3235, 0x3335, 0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935, + 0x3036, 0x3136, 0x3236, 0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936, + 0x3037, 0x3137, 0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937, + 0x3038, 0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938, + 0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839, 0x3939, +} + +var intBELookup = [100]uint16{ + 0x3030, 0x3031, 0x3032, 0x3033, 0x3034, 0x3035, 0x3036, 0x3037, 0x3038, 0x3039, + 0x3130, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137, 0x3138, 0x3139, + 0x3230, 0x3231, 0x3232, 0x3233, 0x3234, 0x3235, 0x3236, 0x3237, 0x3238, 0x3239, + 0x3330, 0x3331, 0x3332, 0x3333, 0x3334, 0x3335, 0x3336, 0x3337, 0x3338, 0x3339, + 0x3430, 0x3431, 0x3432, 0x3433, 0x3434, 0x3435, 0x3436, 0x3437, 0x3438, 0x3439, + 0x3530, 0x3531, 0x3532, 0x3533, 0x3534, 0x3535, 0x3536, 0x3537, 0x3538, 0x3539, + 0x3630, 0x3631, 0x3632, 0x3633, 0x3634, 0x3635, 0x3636, 0x3637, 0x3638, 0x3639, + 0x3730, 0x3731, 0x3732, 0x3733, 0x3734, 0x3735, 0x3736, 0x3737, 0x3738, 0x3739, + 0x3830, 0x3831, 0x3832, 0x3833, 0x3834, 0x3835, 0x3836, 0x3837, 0x3838, 0x3839, + 0x3930, 0x3931, 0x3932, 0x3933, 0x3934, 0x3935, 0x3936, 0x3937, 0x3938, 0x3939, +} + +var intLookup = [2]*[100]uint16{&intLELookup, &intBELookup} + +func numMask(numBitSize uint8) uint64 { + return 1<>(code.NumBitSize-1))&1 == 1 + if !negative { + if n < 10 { + return append(out, byte(n+'0')) + } else if n < 100 { + u := intLELookup[n] + return append(out, byte(u), byte(u>>8)) + } + } else { + n = -n & mask + } + + lookup := intLookup[endianness] + + var b [22]byte + u := (*[11]uint16)(unsafe.Pointer(&b)) + i := 11 + + for n >= 100 { + j := n % 100 + n /= 100 + i-- + u[i] = lookup[j] + } + + i-- + u[i] = lookup[n] + + i *= 2 // convert to byte index + if n < 10 { + i++ // remove leading zero + } + if negative { + i-- + b[i] = '-' + } + + return append(out, b[i:]...) +} + +func AppendUint(_ *RuntimeContext, out []byte, p uintptr, code *Opcode) []byte { + var u64 uint64 + switch code.NumBitSize { + case 8: + u64 = (uint64)(**(**uint8)(unsafe.Pointer(&p))) + case 16: + u64 = (uint64)(**(**uint16)(unsafe.Pointer(&p))) + case 32: + u64 = (uint64)(**(**uint32)(unsafe.Pointer(&p))) + case 64: + u64 = **(**uint64)(unsafe.Pointer(&p)) + } + mask := numMask(code.NumBitSize) + n := u64 & mask + if n < 10 { + return append(out, byte(n+'0')) + } else if n < 100 { + u := intLELookup[n] + return append(out, byte(u), byte(u>>8)) + } + + lookup := intLookup[endianness] + + var b [22]byte + u := (*[11]uint16)(unsafe.Pointer(&b)) + i := 11 + + for n >= 100 { + j := n % 100 + n /= 100 + i-- + u[i] = lookup[j] + } + + i-- + u[i] = lookup[n] + + i *= 2 // convert to byte index + if n < 10 { + i++ // remove leading zero + } + return append(out, b[i:]...) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map112.go b/vendor/github.com/goccy/go-json/internal/encoder/map112.go new file mode 100644 index 00000000..e96ffadf --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/map112.go @@ -0,0 +1,9 @@ +//go:build !go1.13 +// +build !go1.13 + +package encoder + +import "unsafe" + +//go:linkname MapIterValue reflect.mapitervalue +func MapIterValue(it *mapIter) unsafe.Pointer diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map113.go b/vendor/github.com/goccy/go-json/internal/encoder/map113.go new file mode 100644 index 00000000..9b69dcc3 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/map113.go @@ -0,0 +1,9 @@ +//go:build go1.13 +// +build go1.13 + +package encoder + +import "unsafe" + +//go:linkname MapIterValue reflect.mapiterelem +func MapIterValue(it *mapIter) unsafe.Pointer diff --git a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go new file mode 100644 index 00000000..df22f554 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go @@ -0,0 +1,752 @@ +package encoder + +import ( + "bytes" + "fmt" + "sort" + "strings" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +const uintptrSize = 4 << (^uintptr(0) >> 63) + +type OpFlags uint16 + +const ( + AnonymousHeadFlags OpFlags = 1 << 0 + AnonymousKeyFlags OpFlags = 1 << 1 + IndirectFlags OpFlags = 1 << 2 + IsTaggedKeyFlags OpFlags = 1 << 3 + NilCheckFlags OpFlags = 1 << 4 + AddrForMarshalerFlags OpFlags = 1 << 5 + IsNextOpPtrTypeFlags OpFlags = 1 << 6 + IsNilableTypeFlags OpFlags = 1 << 7 + MarshalerContextFlags OpFlags = 1 << 8 + NonEmptyInterfaceFlags OpFlags = 1 << 9 +) + +type Opcode struct { + Op OpType // operation type + Idx uint32 // offset to access ptr + Next *Opcode // next opcode + End *Opcode // array/slice/struct/map end + NextField *Opcode // next struct field + Key string // struct field key + Offset uint32 // offset size from struct header + PtrNum uint8 // pointer number: e.g. double pointer is 2. + NumBitSize uint8 + Flags OpFlags + + Type *runtime.Type // go type + Jmp *CompiledCode // for recursive call + FieldQuery *FieldQuery // field query for Interface / MarshalJSON / MarshalText + ElemIdx uint32 // offset to access array/slice elem + Length uint32 // offset to access slice length or array length + Indent uint32 // indent number + Size uint32 // array/slice elem size + DisplayIdx uint32 // opcode index + DisplayKey string // key text to display +} + +func (c *Opcode) Validate() error { + var prevIdx uint32 + for code := c; !code.IsEnd(); { + if prevIdx != 0 { + if code.DisplayIdx != prevIdx+1 { + return fmt.Errorf( + "invalid index. previous display index is %d but next is %d. dump = %s", + prevIdx, code.DisplayIdx, c.Dump(), + ) + } + } + prevIdx = code.DisplayIdx + code = code.IterNext() + } + return nil +} + +func (c *Opcode) IterNext() *Opcode { + if c == nil { + return nil + } + switch c.Op.CodeType() { + case CodeArrayElem, CodeSliceElem, CodeMapKey: + return c.End + default: + return c.Next + } +} + +func (c *Opcode) IsEnd() bool { + if c == nil { + return true + } + return c.Op == OpEnd || c.Op == OpInterfaceEnd || c.Op == OpRecursiveEnd +} + +func (c *Opcode) MaxIdx() uint32 { + max := uint32(0) + for _, value := range []uint32{ + c.Idx, + c.ElemIdx, + c.Length, + c.Size, + } { + if max < value { + max = value + } + } + return max +} + +func (c *Opcode) ToHeaderType(isString bool) OpType { + switch c.Op { + case OpInt: + if isString { + return OpStructHeadIntString + } + return OpStructHeadInt + case OpIntPtr: + if isString { + return OpStructHeadIntPtrString + } + return OpStructHeadIntPtr + case OpUint: + if isString { + return OpStructHeadUintString + } + return OpStructHeadUint + case OpUintPtr: + if isString { + return OpStructHeadUintPtrString + } + return OpStructHeadUintPtr + case OpFloat32: + if isString { + return OpStructHeadFloat32String + } + return OpStructHeadFloat32 + case OpFloat32Ptr: + if isString { + return OpStructHeadFloat32PtrString + } + return OpStructHeadFloat32Ptr + case OpFloat64: + if isString { + return OpStructHeadFloat64String + } + return OpStructHeadFloat64 + case OpFloat64Ptr: + if isString { + return OpStructHeadFloat64PtrString + } + return OpStructHeadFloat64Ptr + case OpString: + if isString { + return OpStructHeadStringString + } + return OpStructHeadString + case OpStringPtr: + if isString { + return OpStructHeadStringPtrString + } + return OpStructHeadStringPtr + case OpNumber: + if isString { + return OpStructHeadNumberString + } + return OpStructHeadNumber + case OpNumberPtr: + if isString { + return OpStructHeadNumberPtrString + } + return OpStructHeadNumberPtr + case OpBool: + if isString { + return OpStructHeadBoolString + } + return OpStructHeadBool + case OpBoolPtr: + if isString { + return OpStructHeadBoolPtrString + } + return OpStructHeadBoolPtr + case OpBytes: + return OpStructHeadBytes + case OpBytesPtr: + return OpStructHeadBytesPtr + case OpMap: + return OpStructHeadMap + case OpMapPtr: + c.Op = OpMap + return OpStructHeadMapPtr + case OpArray: + return OpStructHeadArray + case OpArrayPtr: + c.Op = OpArray + return OpStructHeadArrayPtr + case OpSlice: + return OpStructHeadSlice + case OpSlicePtr: + c.Op = OpSlice + return OpStructHeadSlicePtr + case OpMarshalJSON: + return OpStructHeadMarshalJSON + case OpMarshalJSONPtr: + return OpStructHeadMarshalJSONPtr + case OpMarshalText: + return OpStructHeadMarshalText + case OpMarshalTextPtr: + return OpStructHeadMarshalTextPtr + } + return OpStructHead +} + +func (c *Opcode) ToFieldType(isString bool) OpType { + switch c.Op { + case OpInt: + if isString { + return OpStructFieldIntString + } + return OpStructFieldInt + case OpIntPtr: + if isString { + return OpStructFieldIntPtrString + } + return OpStructFieldIntPtr + case OpUint: + if isString { + return OpStructFieldUintString + } + return OpStructFieldUint + case OpUintPtr: + if isString { + return OpStructFieldUintPtrString + } + return OpStructFieldUintPtr + case OpFloat32: + if isString { + return OpStructFieldFloat32String + } + return OpStructFieldFloat32 + case OpFloat32Ptr: + if isString { + return OpStructFieldFloat32PtrString + } + return OpStructFieldFloat32Ptr + case OpFloat64: + if isString { + return OpStructFieldFloat64String + } + return OpStructFieldFloat64 + case OpFloat64Ptr: + if isString { + return OpStructFieldFloat64PtrString + } + return OpStructFieldFloat64Ptr + case OpString: + if isString { + return OpStructFieldStringString + } + return OpStructFieldString + case OpStringPtr: + if isString { + return OpStructFieldStringPtrString + } + return OpStructFieldStringPtr + case OpNumber: + if isString { + return OpStructFieldNumberString + } + return OpStructFieldNumber + case OpNumberPtr: + if isString { + return OpStructFieldNumberPtrString + } + return OpStructFieldNumberPtr + case OpBool: + if isString { + return OpStructFieldBoolString + } + return OpStructFieldBool + case OpBoolPtr: + if isString { + return OpStructFieldBoolPtrString + } + return OpStructFieldBoolPtr + case OpBytes: + return OpStructFieldBytes + case OpBytesPtr: + return OpStructFieldBytesPtr + case OpMap: + return OpStructFieldMap + case OpMapPtr: + c.Op = OpMap + return OpStructFieldMapPtr + case OpArray: + return OpStructFieldArray + case OpArrayPtr: + c.Op = OpArray + return OpStructFieldArrayPtr + case OpSlice: + return OpStructFieldSlice + case OpSlicePtr: + c.Op = OpSlice + return OpStructFieldSlicePtr + case OpMarshalJSON: + return OpStructFieldMarshalJSON + case OpMarshalJSONPtr: + return OpStructFieldMarshalJSONPtr + case OpMarshalText: + return OpStructFieldMarshalText + case OpMarshalTextPtr: + return OpStructFieldMarshalTextPtr + } + return OpStructField +} + +func newOpCode(ctx *compileContext, typ *runtime.Type, op OpType) *Opcode { + return newOpCodeWithNext(ctx, typ, op, newEndOp(ctx, typ)) +} + +func opcodeOffset(idx int) uint32 { + return uint32(idx) * uintptrSize +} + +func getCodeAddrByIdx(head *Opcode, idx uint32) *Opcode { + addr := uintptr(unsafe.Pointer(head)) + uintptr(idx)*unsafe.Sizeof(Opcode{}) + return *(**Opcode)(unsafe.Pointer(&addr)) +} + +func copyOpcode(code *Opcode) *Opcode { + codeNum := ToEndCode(code).DisplayIdx + 1 + codeSlice := make([]Opcode, codeNum) + head := (*Opcode)((*runtime.SliceHeader)(unsafe.Pointer(&codeSlice)).Data) + ptr := head + c := code + for { + *ptr = Opcode{ + Op: c.Op, + Key: c.Key, + PtrNum: c.PtrNum, + NumBitSize: c.NumBitSize, + Flags: c.Flags, + Idx: c.Idx, + Offset: c.Offset, + Type: c.Type, + FieldQuery: c.FieldQuery, + DisplayIdx: c.DisplayIdx, + DisplayKey: c.DisplayKey, + ElemIdx: c.ElemIdx, + Length: c.Length, + Size: c.Size, + Indent: c.Indent, + Jmp: c.Jmp, + } + if c.End != nil { + ptr.End = getCodeAddrByIdx(head, c.End.DisplayIdx) + } + if c.NextField != nil { + ptr.NextField = getCodeAddrByIdx(head, c.NextField.DisplayIdx) + } + if c.Next != nil { + ptr.Next = getCodeAddrByIdx(head, c.Next.DisplayIdx) + } + if c.IsEnd() { + break + } + ptr = getCodeAddrByIdx(head, c.DisplayIdx+1) + c = c.IterNext() + } + return head +} + +func setTotalLengthToInterfaceOp(code *Opcode) { + for c := code; !c.IsEnd(); { + if c.Op == OpInterface || c.Op == OpInterfacePtr { + c.Length = uint32(code.TotalLength()) + } + c = c.IterNext() + } +} + +func ToEndCode(code *Opcode) *Opcode { + c := code + for !c.IsEnd() { + c = c.IterNext() + } + return c +} + +func copyToInterfaceOpcode(code *Opcode) *Opcode { + copied := copyOpcode(code) + c := copied + c = ToEndCode(c) + c.Idx += uintptrSize + c.ElemIdx = c.Idx + uintptrSize + c.Length = c.Idx + 2*uintptrSize + c.Op = OpInterfaceEnd + return copied +} + +func newOpCodeWithNext(ctx *compileContext, typ *runtime.Type, op OpType, next *Opcode) *Opcode { + return &Opcode{ + Op: op, + Idx: opcodeOffset(ctx.ptrIndex), + Next: next, + Type: typ, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } +} + +func newEndOp(ctx *compileContext, typ *runtime.Type) *Opcode { + return newOpCodeWithNext(ctx, typ, OpEnd, nil) +} + +func (c *Opcode) TotalLength() int { + var idx int + code := c + for !code.IsEnd() { + maxIdx := int(code.MaxIdx() / uintptrSize) + if idx < maxIdx { + idx = maxIdx + } + if code.Op == OpRecursiveEnd { + break + } + code = code.IterNext() + } + maxIdx := int(code.MaxIdx() / uintptrSize) + if idx < maxIdx { + idx = maxIdx + } + return idx + 1 +} + +func (c *Opcode) dumpHead(code *Opcode) string { + var length uint32 + if code.Op.CodeType() == CodeArrayHead { + length = code.Length + } else { + length = code.Length / uintptrSize + } + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + code.ElemIdx/uintptrSize, + length, + ) +} + +func (c *Opcode) dumpMapHead(code *Opcode) string { + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + ) +} + +func (c *Opcode) dumpMapEnd(code *Opcode) string { + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + ) +} + +func (c *Opcode) dumpElem(code *Opcode) string { + var length uint32 + if code.Op.CodeType() == CodeArrayElem { + length = code.Length + } else { + length = code.Length / uintptrSize + } + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d][size:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + code.ElemIdx/uintptrSize, + length, + code.Size, + ) +} + +func (c *Opcode) dumpField(code *Opcode) string { + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d][key:%s][offset:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + code.DisplayKey, + code.Offset, + ) +} + +func (c *Opcode) dumpKey(code *Opcode) string { + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + ) +} + +func (c *Opcode) dumpValue(code *Opcode) string { + return fmt.Sprintf( + `[%03d]%s%s ([idx:%d])`, + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + ) +} + +func (c *Opcode) Dump() string { + codes := []string{} + for code := c; !code.IsEnd(); { + switch code.Op.CodeType() { + case CodeSliceHead: + codes = append(codes, c.dumpHead(code)) + code = code.Next + case CodeMapHead: + codes = append(codes, c.dumpMapHead(code)) + code = code.Next + case CodeArrayElem, CodeSliceElem: + codes = append(codes, c.dumpElem(code)) + code = code.End + case CodeMapKey: + codes = append(codes, c.dumpKey(code)) + code = code.End + case CodeMapValue: + codes = append(codes, c.dumpValue(code)) + code = code.Next + case CodeMapEnd: + codes = append(codes, c.dumpMapEnd(code)) + code = code.Next + case CodeStructField: + codes = append(codes, c.dumpField(code)) + code = code.Next + case CodeStructEnd: + codes = append(codes, c.dumpField(code)) + code = code.Next + default: + codes = append(codes, fmt.Sprintf( + "[%03d]%s%s ([idx:%d])", + code.DisplayIdx, + strings.Repeat("-", int(code.Indent)), + code.Op, + code.Idx/uintptrSize, + )) + code = code.Next + } + } + return strings.Join(codes, "\n") +} + +func (c *Opcode) DumpDOT() string { + type edge struct { + from, to *Opcode + label string + weight int + } + var edges []edge + + b := &bytes.Buffer{} + fmt.Fprintf(b, "digraph \"%p\" {\n", c.Type) + fmt.Fprintln(b, "mclimit=1.5;\nrankdir=TD;\nordering=out;\nnode[shape=box];") + for code := c; !code.IsEnd(); { + label := code.Op.String() + fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, label) + if p := code.Next; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "Next", + weight: 10, + }) + } + if p := code.NextField; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "NextField", + weight: 2, + }) + } + if p := code.End; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "End", + weight: 1, + }) + } + if p := code.Jmp; p != nil { + edges = append(edges, edge{ + from: code, + to: p.Code, + label: "Jmp", + weight: 1, + }) + } + + switch code.Op.CodeType() { + case CodeSliceHead: + code = code.Next + case CodeMapHead: + code = code.Next + case CodeArrayElem, CodeSliceElem: + code = code.End + case CodeMapKey: + code = code.End + case CodeMapValue: + code = code.Next + case CodeMapEnd: + code = code.Next + case CodeStructField: + code = code.Next + case CodeStructEnd: + code = code.Next + default: + code = code.Next + } + if code.IsEnd() { + fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, code.Op.String()) + } + } + sort.Slice(edges, func(i, j int) bool { + return edges[i].to.DisplayIdx < edges[j].to.DisplayIdx + }) + for _, e := range edges { + fmt.Fprintf(b, "\"%p\" -> \"%p\" [label=%q][weight=%d];\n", e.from, e.to, e.label, e.weight) + } + fmt.Fprint(b, "}") + return b.String() +} + +func newSliceHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode { + idx := opcodeOffset(ctx.ptrIndex) + ctx.incPtrIndex() + elemIdx := opcodeOffset(ctx.ptrIndex) + ctx.incPtrIndex() + length := opcodeOffset(ctx.ptrIndex) + return &Opcode{ + Op: OpSlice, + Type: typ, + Idx: idx, + DisplayIdx: ctx.opcodeIndex, + ElemIdx: elemIdx, + Length: length, + Indent: ctx.indent, + } +} + +func newSliceElemCode(ctx *compileContext, typ *runtime.Type, head *Opcode, size uintptr) *Opcode { + return &Opcode{ + Op: OpSliceElem, + Type: typ, + Idx: head.Idx, + DisplayIdx: ctx.opcodeIndex, + ElemIdx: head.ElemIdx, + Length: head.Length, + Indent: ctx.indent, + Size: uint32(size), + } +} + +func newArrayHeaderCode(ctx *compileContext, typ *runtime.Type, alen int) *Opcode { + idx := opcodeOffset(ctx.ptrIndex) + ctx.incPtrIndex() + elemIdx := opcodeOffset(ctx.ptrIndex) + return &Opcode{ + Op: OpArray, + Type: typ, + Idx: idx, + DisplayIdx: ctx.opcodeIndex, + ElemIdx: elemIdx, + Indent: ctx.indent, + Length: uint32(alen), + } +} + +func newArrayElemCode(ctx *compileContext, typ *runtime.Type, head *Opcode, length int, size uintptr) *Opcode { + return &Opcode{ + Op: OpArrayElem, + Type: typ, + Idx: head.Idx, + DisplayIdx: ctx.opcodeIndex, + ElemIdx: head.ElemIdx, + Length: uint32(length), + Indent: ctx.indent, + Size: uint32(size), + } +} + +func newMapHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode { + idx := opcodeOffset(ctx.ptrIndex) + ctx.incPtrIndex() + return &Opcode{ + Op: OpMap, + Type: typ, + Idx: idx, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } +} + +func newMapKeyCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode { + return &Opcode{ + Op: OpMapKey, + Type: typ, + Idx: head.Idx, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } +} + +func newMapValueCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode { + return &Opcode{ + Op: OpMapValue, + Type: typ, + Idx: head.Idx, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + } +} + +func newMapEndCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode { + return &Opcode{ + Op: OpMapEnd, + Type: typ, + Idx: head.Idx, + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + Next: newEndOp(ctx, typ), + } +} + +func newRecursiveCode(ctx *compileContext, typ *runtime.Type, jmp *CompiledCode) *Opcode { + return &Opcode{ + Op: OpRecursive, + Type: typ, + Idx: opcodeOffset(ctx.ptrIndex), + Next: newEndOp(ctx, typ), + DisplayIdx: ctx.opcodeIndex, + Indent: ctx.indent, + Jmp: jmp, + } +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/option.go b/vendor/github.com/goccy/go-json/internal/encoder/option.go new file mode 100644 index 00000000..12c58e46 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/option.go @@ -0,0 +1,48 @@ +package encoder + +import ( + "context" + "io" +) + +type OptionFlag uint8 + +const ( + HTMLEscapeOption OptionFlag = 1 << iota + IndentOption + UnorderedMapOption + DebugOption + ColorizeOption + ContextOption + NormalizeUTF8Option + FieldQueryOption +) + +type Option struct { + Flag OptionFlag + ColorScheme *ColorScheme + Context context.Context + DebugOut io.Writer + DebugDOTOut io.WriteCloser +} + +type EncodeFormat struct { + Header string + Footer string +} + +type EncodeFormatScheme struct { + Int EncodeFormat + Uint EncodeFormat + Float EncodeFormat + Bool EncodeFormat + String EncodeFormat + Binary EncodeFormat + ObjectKey EncodeFormat + Null EncodeFormat +} + +type ( + ColorScheme = EncodeFormatScheme + ColorFormat = EncodeFormat +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/optype.go b/vendor/github.com/goccy/go-json/internal/encoder/optype.go new file mode 100644 index 00000000..5c1241b4 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/optype.go @@ -0,0 +1,932 @@ +// Code generated by internal/cmd/generator. DO NOT EDIT! +package encoder + +import ( + "strings" +) + +type CodeType int + +const ( + CodeOp CodeType = 0 + CodeArrayHead CodeType = 1 + CodeArrayElem CodeType = 2 + CodeSliceHead CodeType = 3 + CodeSliceElem CodeType = 4 + CodeMapHead CodeType = 5 + CodeMapKey CodeType = 6 + CodeMapValue CodeType = 7 + CodeMapEnd CodeType = 8 + CodeRecursive CodeType = 9 + CodeStructField CodeType = 10 + CodeStructEnd CodeType = 11 +) + +var opTypeStrings = [400]string{ + "End", + "Interface", + "Ptr", + "SliceElem", + "SliceEnd", + "ArrayElem", + "ArrayEnd", + "MapKey", + "MapValue", + "MapEnd", + "Recursive", + "RecursivePtr", + "RecursiveEnd", + "InterfaceEnd", + "Int", + "Uint", + "Float32", + "Float64", + "Bool", + "String", + "Bytes", + "Number", + "Array", + "Map", + "Slice", + "Struct", + "MarshalJSON", + "MarshalText", + "IntString", + "UintString", + "Float32String", + "Float64String", + "BoolString", + "StringString", + "NumberString", + "IntPtr", + "UintPtr", + "Float32Ptr", + "Float64Ptr", + "BoolPtr", + "StringPtr", + "BytesPtr", + "NumberPtr", + "ArrayPtr", + "MapPtr", + "SlicePtr", + "MarshalJSONPtr", + "MarshalTextPtr", + "InterfacePtr", + "IntPtrString", + "UintPtrString", + "Float32PtrString", + "Float64PtrString", + "BoolPtrString", + "StringPtrString", + "NumberPtrString", + "StructHeadInt", + "StructHeadOmitEmptyInt", + "StructPtrHeadInt", + "StructPtrHeadOmitEmptyInt", + "StructHeadUint", + "StructHeadOmitEmptyUint", + "StructPtrHeadUint", + "StructPtrHeadOmitEmptyUint", + "StructHeadFloat32", + "StructHeadOmitEmptyFloat32", + "StructPtrHeadFloat32", + "StructPtrHeadOmitEmptyFloat32", + "StructHeadFloat64", + "StructHeadOmitEmptyFloat64", + "StructPtrHeadFloat64", + "StructPtrHeadOmitEmptyFloat64", + "StructHeadBool", + "StructHeadOmitEmptyBool", + "StructPtrHeadBool", + "StructPtrHeadOmitEmptyBool", + "StructHeadString", + "StructHeadOmitEmptyString", + "StructPtrHeadString", + "StructPtrHeadOmitEmptyString", + "StructHeadBytes", + "StructHeadOmitEmptyBytes", + "StructPtrHeadBytes", + "StructPtrHeadOmitEmptyBytes", + "StructHeadNumber", + "StructHeadOmitEmptyNumber", + "StructPtrHeadNumber", + "StructPtrHeadOmitEmptyNumber", + "StructHeadArray", + "StructHeadOmitEmptyArray", + "StructPtrHeadArray", + "StructPtrHeadOmitEmptyArray", + "StructHeadMap", + "StructHeadOmitEmptyMap", + "StructPtrHeadMap", + "StructPtrHeadOmitEmptyMap", + "StructHeadSlice", + "StructHeadOmitEmptySlice", + "StructPtrHeadSlice", + "StructPtrHeadOmitEmptySlice", + "StructHeadStruct", + "StructHeadOmitEmptyStruct", + "StructPtrHeadStruct", + "StructPtrHeadOmitEmptyStruct", + "StructHeadMarshalJSON", + "StructHeadOmitEmptyMarshalJSON", + "StructPtrHeadMarshalJSON", + "StructPtrHeadOmitEmptyMarshalJSON", + "StructHeadMarshalText", + "StructHeadOmitEmptyMarshalText", + "StructPtrHeadMarshalText", + "StructPtrHeadOmitEmptyMarshalText", + "StructHeadIntString", + "StructHeadOmitEmptyIntString", + "StructPtrHeadIntString", + "StructPtrHeadOmitEmptyIntString", + "StructHeadUintString", + "StructHeadOmitEmptyUintString", + "StructPtrHeadUintString", + "StructPtrHeadOmitEmptyUintString", + "StructHeadFloat32String", + "StructHeadOmitEmptyFloat32String", + "StructPtrHeadFloat32String", + "StructPtrHeadOmitEmptyFloat32String", + "StructHeadFloat64String", + "StructHeadOmitEmptyFloat64String", + "StructPtrHeadFloat64String", + "StructPtrHeadOmitEmptyFloat64String", + "StructHeadBoolString", + "StructHeadOmitEmptyBoolString", + "StructPtrHeadBoolString", + "StructPtrHeadOmitEmptyBoolString", + "StructHeadStringString", + "StructHeadOmitEmptyStringString", + "StructPtrHeadStringString", + "StructPtrHeadOmitEmptyStringString", + "StructHeadNumberString", + "StructHeadOmitEmptyNumberString", + "StructPtrHeadNumberString", + "StructPtrHeadOmitEmptyNumberString", + "StructHeadIntPtr", + "StructHeadOmitEmptyIntPtr", + "StructPtrHeadIntPtr", + "StructPtrHeadOmitEmptyIntPtr", + "StructHeadUintPtr", + "StructHeadOmitEmptyUintPtr", + "StructPtrHeadUintPtr", + "StructPtrHeadOmitEmptyUintPtr", + "StructHeadFloat32Ptr", + "StructHeadOmitEmptyFloat32Ptr", + "StructPtrHeadFloat32Ptr", + "StructPtrHeadOmitEmptyFloat32Ptr", + "StructHeadFloat64Ptr", + "StructHeadOmitEmptyFloat64Ptr", + "StructPtrHeadFloat64Ptr", + "StructPtrHeadOmitEmptyFloat64Ptr", + "StructHeadBoolPtr", + "StructHeadOmitEmptyBoolPtr", + "StructPtrHeadBoolPtr", + "StructPtrHeadOmitEmptyBoolPtr", + "StructHeadStringPtr", + "StructHeadOmitEmptyStringPtr", + "StructPtrHeadStringPtr", + "StructPtrHeadOmitEmptyStringPtr", + "StructHeadBytesPtr", + "StructHeadOmitEmptyBytesPtr", + "StructPtrHeadBytesPtr", + "StructPtrHeadOmitEmptyBytesPtr", + "StructHeadNumberPtr", + "StructHeadOmitEmptyNumberPtr", + "StructPtrHeadNumberPtr", + "StructPtrHeadOmitEmptyNumberPtr", + "StructHeadArrayPtr", + "StructHeadOmitEmptyArrayPtr", + "StructPtrHeadArrayPtr", + "StructPtrHeadOmitEmptyArrayPtr", + "StructHeadMapPtr", + "StructHeadOmitEmptyMapPtr", + "StructPtrHeadMapPtr", + "StructPtrHeadOmitEmptyMapPtr", + "StructHeadSlicePtr", + "StructHeadOmitEmptySlicePtr", + "StructPtrHeadSlicePtr", + "StructPtrHeadOmitEmptySlicePtr", + "StructHeadMarshalJSONPtr", + "StructHeadOmitEmptyMarshalJSONPtr", + "StructPtrHeadMarshalJSONPtr", + "StructPtrHeadOmitEmptyMarshalJSONPtr", + "StructHeadMarshalTextPtr", + "StructHeadOmitEmptyMarshalTextPtr", + "StructPtrHeadMarshalTextPtr", + "StructPtrHeadOmitEmptyMarshalTextPtr", + "StructHeadInterfacePtr", + "StructHeadOmitEmptyInterfacePtr", + "StructPtrHeadInterfacePtr", + "StructPtrHeadOmitEmptyInterfacePtr", + "StructHeadIntPtrString", + "StructHeadOmitEmptyIntPtrString", + "StructPtrHeadIntPtrString", + "StructPtrHeadOmitEmptyIntPtrString", + "StructHeadUintPtrString", + "StructHeadOmitEmptyUintPtrString", + "StructPtrHeadUintPtrString", + "StructPtrHeadOmitEmptyUintPtrString", + "StructHeadFloat32PtrString", + "StructHeadOmitEmptyFloat32PtrString", + "StructPtrHeadFloat32PtrString", + "StructPtrHeadOmitEmptyFloat32PtrString", + "StructHeadFloat64PtrString", + "StructHeadOmitEmptyFloat64PtrString", + "StructPtrHeadFloat64PtrString", + "StructPtrHeadOmitEmptyFloat64PtrString", + "StructHeadBoolPtrString", + "StructHeadOmitEmptyBoolPtrString", + "StructPtrHeadBoolPtrString", + "StructPtrHeadOmitEmptyBoolPtrString", + "StructHeadStringPtrString", + "StructHeadOmitEmptyStringPtrString", + "StructPtrHeadStringPtrString", + "StructPtrHeadOmitEmptyStringPtrString", + "StructHeadNumberPtrString", + "StructHeadOmitEmptyNumberPtrString", + "StructPtrHeadNumberPtrString", + "StructPtrHeadOmitEmptyNumberPtrString", + "StructHead", + "StructHeadOmitEmpty", + "StructPtrHead", + "StructPtrHeadOmitEmpty", + "StructFieldInt", + "StructFieldOmitEmptyInt", + "StructEndInt", + "StructEndOmitEmptyInt", + "StructFieldUint", + "StructFieldOmitEmptyUint", + "StructEndUint", + "StructEndOmitEmptyUint", + "StructFieldFloat32", + "StructFieldOmitEmptyFloat32", + "StructEndFloat32", + "StructEndOmitEmptyFloat32", + "StructFieldFloat64", + "StructFieldOmitEmptyFloat64", + "StructEndFloat64", + "StructEndOmitEmptyFloat64", + "StructFieldBool", + "StructFieldOmitEmptyBool", + "StructEndBool", + "StructEndOmitEmptyBool", + "StructFieldString", + "StructFieldOmitEmptyString", + "StructEndString", + "StructEndOmitEmptyString", + "StructFieldBytes", + "StructFieldOmitEmptyBytes", + "StructEndBytes", + "StructEndOmitEmptyBytes", + "StructFieldNumber", + "StructFieldOmitEmptyNumber", + "StructEndNumber", + "StructEndOmitEmptyNumber", + "StructFieldArray", + "StructFieldOmitEmptyArray", + "StructEndArray", + "StructEndOmitEmptyArray", + "StructFieldMap", + "StructFieldOmitEmptyMap", + "StructEndMap", + "StructEndOmitEmptyMap", + "StructFieldSlice", + "StructFieldOmitEmptySlice", + "StructEndSlice", + "StructEndOmitEmptySlice", + "StructFieldStruct", + "StructFieldOmitEmptyStruct", + "StructEndStruct", + "StructEndOmitEmptyStruct", + "StructFieldMarshalJSON", + "StructFieldOmitEmptyMarshalJSON", + "StructEndMarshalJSON", + "StructEndOmitEmptyMarshalJSON", + "StructFieldMarshalText", + "StructFieldOmitEmptyMarshalText", + "StructEndMarshalText", + "StructEndOmitEmptyMarshalText", + "StructFieldIntString", + "StructFieldOmitEmptyIntString", + "StructEndIntString", + "StructEndOmitEmptyIntString", + "StructFieldUintString", + "StructFieldOmitEmptyUintString", + "StructEndUintString", + "StructEndOmitEmptyUintString", + "StructFieldFloat32String", + "StructFieldOmitEmptyFloat32String", + "StructEndFloat32String", + "StructEndOmitEmptyFloat32String", + "StructFieldFloat64String", + "StructFieldOmitEmptyFloat64String", + "StructEndFloat64String", + "StructEndOmitEmptyFloat64String", + "StructFieldBoolString", + "StructFieldOmitEmptyBoolString", + "StructEndBoolString", + "StructEndOmitEmptyBoolString", + "StructFieldStringString", + "StructFieldOmitEmptyStringString", + "StructEndStringString", + "StructEndOmitEmptyStringString", + "StructFieldNumberString", + "StructFieldOmitEmptyNumberString", + "StructEndNumberString", + "StructEndOmitEmptyNumberString", + "StructFieldIntPtr", + "StructFieldOmitEmptyIntPtr", + "StructEndIntPtr", + "StructEndOmitEmptyIntPtr", + "StructFieldUintPtr", + "StructFieldOmitEmptyUintPtr", + "StructEndUintPtr", + "StructEndOmitEmptyUintPtr", + "StructFieldFloat32Ptr", + "StructFieldOmitEmptyFloat32Ptr", + "StructEndFloat32Ptr", + "StructEndOmitEmptyFloat32Ptr", + "StructFieldFloat64Ptr", + "StructFieldOmitEmptyFloat64Ptr", + "StructEndFloat64Ptr", + "StructEndOmitEmptyFloat64Ptr", + "StructFieldBoolPtr", + "StructFieldOmitEmptyBoolPtr", + "StructEndBoolPtr", + "StructEndOmitEmptyBoolPtr", + "StructFieldStringPtr", + "StructFieldOmitEmptyStringPtr", + "StructEndStringPtr", + "StructEndOmitEmptyStringPtr", + "StructFieldBytesPtr", + "StructFieldOmitEmptyBytesPtr", + "StructEndBytesPtr", + "StructEndOmitEmptyBytesPtr", + "StructFieldNumberPtr", + "StructFieldOmitEmptyNumberPtr", + "StructEndNumberPtr", + "StructEndOmitEmptyNumberPtr", + "StructFieldArrayPtr", + "StructFieldOmitEmptyArrayPtr", + "StructEndArrayPtr", + "StructEndOmitEmptyArrayPtr", + "StructFieldMapPtr", + "StructFieldOmitEmptyMapPtr", + "StructEndMapPtr", + "StructEndOmitEmptyMapPtr", + "StructFieldSlicePtr", + "StructFieldOmitEmptySlicePtr", + "StructEndSlicePtr", + "StructEndOmitEmptySlicePtr", + "StructFieldMarshalJSONPtr", + "StructFieldOmitEmptyMarshalJSONPtr", + "StructEndMarshalJSONPtr", + "StructEndOmitEmptyMarshalJSONPtr", + "StructFieldMarshalTextPtr", + "StructFieldOmitEmptyMarshalTextPtr", + "StructEndMarshalTextPtr", + "StructEndOmitEmptyMarshalTextPtr", + "StructFieldInterfacePtr", + "StructFieldOmitEmptyInterfacePtr", + "StructEndInterfacePtr", + "StructEndOmitEmptyInterfacePtr", + "StructFieldIntPtrString", + "StructFieldOmitEmptyIntPtrString", + "StructEndIntPtrString", + "StructEndOmitEmptyIntPtrString", + "StructFieldUintPtrString", + "StructFieldOmitEmptyUintPtrString", + "StructEndUintPtrString", + "StructEndOmitEmptyUintPtrString", + "StructFieldFloat32PtrString", + "StructFieldOmitEmptyFloat32PtrString", + "StructEndFloat32PtrString", + "StructEndOmitEmptyFloat32PtrString", + "StructFieldFloat64PtrString", + "StructFieldOmitEmptyFloat64PtrString", + "StructEndFloat64PtrString", + "StructEndOmitEmptyFloat64PtrString", + "StructFieldBoolPtrString", + "StructFieldOmitEmptyBoolPtrString", + "StructEndBoolPtrString", + "StructEndOmitEmptyBoolPtrString", + "StructFieldStringPtrString", + "StructFieldOmitEmptyStringPtrString", + "StructEndStringPtrString", + "StructEndOmitEmptyStringPtrString", + "StructFieldNumberPtrString", + "StructFieldOmitEmptyNumberPtrString", + "StructEndNumberPtrString", + "StructEndOmitEmptyNumberPtrString", + "StructField", + "StructFieldOmitEmpty", + "StructEnd", + "StructEndOmitEmpty", +} + +type OpType uint16 + +const ( + OpEnd OpType = 0 + OpInterface OpType = 1 + OpPtr OpType = 2 + OpSliceElem OpType = 3 + OpSliceEnd OpType = 4 + OpArrayElem OpType = 5 + OpArrayEnd OpType = 6 + OpMapKey OpType = 7 + OpMapValue OpType = 8 + OpMapEnd OpType = 9 + OpRecursive OpType = 10 + OpRecursivePtr OpType = 11 + OpRecursiveEnd OpType = 12 + OpInterfaceEnd OpType = 13 + OpInt OpType = 14 + OpUint OpType = 15 + OpFloat32 OpType = 16 + OpFloat64 OpType = 17 + OpBool OpType = 18 + OpString OpType = 19 + OpBytes OpType = 20 + OpNumber OpType = 21 + OpArray OpType = 22 + OpMap OpType = 23 + OpSlice OpType = 24 + OpStruct OpType = 25 + OpMarshalJSON OpType = 26 + OpMarshalText OpType = 27 + OpIntString OpType = 28 + OpUintString OpType = 29 + OpFloat32String OpType = 30 + OpFloat64String OpType = 31 + OpBoolString OpType = 32 + OpStringString OpType = 33 + OpNumberString OpType = 34 + OpIntPtr OpType = 35 + OpUintPtr OpType = 36 + OpFloat32Ptr OpType = 37 + OpFloat64Ptr OpType = 38 + OpBoolPtr OpType = 39 + OpStringPtr OpType = 40 + OpBytesPtr OpType = 41 + OpNumberPtr OpType = 42 + OpArrayPtr OpType = 43 + OpMapPtr OpType = 44 + OpSlicePtr OpType = 45 + OpMarshalJSONPtr OpType = 46 + OpMarshalTextPtr OpType = 47 + OpInterfacePtr OpType = 48 + OpIntPtrString OpType = 49 + OpUintPtrString OpType = 50 + OpFloat32PtrString OpType = 51 + OpFloat64PtrString OpType = 52 + OpBoolPtrString OpType = 53 + OpStringPtrString OpType = 54 + OpNumberPtrString OpType = 55 + OpStructHeadInt OpType = 56 + OpStructHeadOmitEmptyInt OpType = 57 + OpStructPtrHeadInt OpType = 58 + OpStructPtrHeadOmitEmptyInt OpType = 59 + OpStructHeadUint OpType = 60 + OpStructHeadOmitEmptyUint OpType = 61 + OpStructPtrHeadUint OpType = 62 + OpStructPtrHeadOmitEmptyUint OpType = 63 + OpStructHeadFloat32 OpType = 64 + OpStructHeadOmitEmptyFloat32 OpType = 65 + OpStructPtrHeadFloat32 OpType = 66 + OpStructPtrHeadOmitEmptyFloat32 OpType = 67 + OpStructHeadFloat64 OpType = 68 + OpStructHeadOmitEmptyFloat64 OpType = 69 + OpStructPtrHeadFloat64 OpType = 70 + OpStructPtrHeadOmitEmptyFloat64 OpType = 71 + OpStructHeadBool OpType = 72 + OpStructHeadOmitEmptyBool OpType = 73 + OpStructPtrHeadBool OpType = 74 + OpStructPtrHeadOmitEmptyBool OpType = 75 + OpStructHeadString OpType = 76 + OpStructHeadOmitEmptyString OpType = 77 + OpStructPtrHeadString OpType = 78 + OpStructPtrHeadOmitEmptyString OpType = 79 + OpStructHeadBytes OpType = 80 + OpStructHeadOmitEmptyBytes OpType = 81 + OpStructPtrHeadBytes OpType = 82 + OpStructPtrHeadOmitEmptyBytes OpType = 83 + OpStructHeadNumber OpType = 84 + OpStructHeadOmitEmptyNumber OpType = 85 + OpStructPtrHeadNumber OpType = 86 + OpStructPtrHeadOmitEmptyNumber OpType = 87 + OpStructHeadArray OpType = 88 + OpStructHeadOmitEmptyArray OpType = 89 + OpStructPtrHeadArray OpType = 90 + OpStructPtrHeadOmitEmptyArray OpType = 91 + OpStructHeadMap OpType = 92 + OpStructHeadOmitEmptyMap OpType = 93 + OpStructPtrHeadMap OpType = 94 + OpStructPtrHeadOmitEmptyMap OpType = 95 + OpStructHeadSlice OpType = 96 + OpStructHeadOmitEmptySlice OpType = 97 + OpStructPtrHeadSlice OpType = 98 + OpStructPtrHeadOmitEmptySlice OpType = 99 + OpStructHeadStruct OpType = 100 + OpStructHeadOmitEmptyStruct OpType = 101 + OpStructPtrHeadStruct OpType = 102 + OpStructPtrHeadOmitEmptyStruct OpType = 103 + OpStructHeadMarshalJSON OpType = 104 + OpStructHeadOmitEmptyMarshalJSON OpType = 105 + OpStructPtrHeadMarshalJSON OpType = 106 + OpStructPtrHeadOmitEmptyMarshalJSON OpType = 107 + OpStructHeadMarshalText OpType = 108 + OpStructHeadOmitEmptyMarshalText OpType = 109 + OpStructPtrHeadMarshalText OpType = 110 + OpStructPtrHeadOmitEmptyMarshalText OpType = 111 + OpStructHeadIntString OpType = 112 + OpStructHeadOmitEmptyIntString OpType = 113 + OpStructPtrHeadIntString OpType = 114 + OpStructPtrHeadOmitEmptyIntString OpType = 115 + OpStructHeadUintString OpType = 116 + OpStructHeadOmitEmptyUintString OpType = 117 + OpStructPtrHeadUintString OpType = 118 + OpStructPtrHeadOmitEmptyUintString OpType = 119 + OpStructHeadFloat32String OpType = 120 + OpStructHeadOmitEmptyFloat32String OpType = 121 + OpStructPtrHeadFloat32String OpType = 122 + OpStructPtrHeadOmitEmptyFloat32String OpType = 123 + OpStructHeadFloat64String OpType = 124 + OpStructHeadOmitEmptyFloat64String OpType = 125 + OpStructPtrHeadFloat64String OpType = 126 + OpStructPtrHeadOmitEmptyFloat64String OpType = 127 + OpStructHeadBoolString OpType = 128 + OpStructHeadOmitEmptyBoolString OpType = 129 + OpStructPtrHeadBoolString OpType = 130 + OpStructPtrHeadOmitEmptyBoolString OpType = 131 + OpStructHeadStringString OpType = 132 + OpStructHeadOmitEmptyStringString OpType = 133 + OpStructPtrHeadStringString OpType = 134 + OpStructPtrHeadOmitEmptyStringString OpType = 135 + OpStructHeadNumberString OpType = 136 + OpStructHeadOmitEmptyNumberString OpType = 137 + OpStructPtrHeadNumberString OpType = 138 + OpStructPtrHeadOmitEmptyNumberString OpType = 139 + OpStructHeadIntPtr OpType = 140 + OpStructHeadOmitEmptyIntPtr OpType = 141 + OpStructPtrHeadIntPtr OpType = 142 + OpStructPtrHeadOmitEmptyIntPtr OpType = 143 + OpStructHeadUintPtr OpType = 144 + OpStructHeadOmitEmptyUintPtr OpType = 145 + OpStructPtrHeadUintPtr OpType = 146 + OpStructPtrHeadOmitEmptyUintPtr OpType = 147 + OpStructHeadFloat32Ptr OpType = 148 + OpStructHeadOmitEmptyFloat32Ptr OpType = 149 + OpStructPtrHeadFloat32Ptr OpType = 150 + OpStructPtrHeadOmitEmptyFloat32Ptr OpType = 151 + OpStructHeadFloat64Ptr OpType = 152 + OpStructHeadOmitEmptyFloat64Ptr OpType = 153 + OpStructPtrHeadFloat64Ptr OpType = 154 + OpStructPtrHeadOmitEmptyFloat64Ptr OpType = 155 + OpStructHeadBoolPtr OpType = 156 + OpStructHeadOmitEmptyBoolPtr OpType = 157 + OpStructPtrHeadBoolPtr OpType = 158 + OpStructPtrHeadOmitEmptyBoolPtr OpType = 159 + OpStructHeadStringPtr OpType = 160 + OpStructHeadOmitEmptyStringPtr OpType = 161 + OpStructPtrHeadStringPtr OpType = 162 + OpStructPtrHeadOmitEmptyStringPtr OpType = 163 + OpStructHeadBytesPtr OpType = 164 + OpStructHeadOmitEmptyBytesPtr OpType = 165 + OpStructPtrHeadBytesPtr OpType = 166 + OpStructPtrHeadOmitEmptyBytesPtr OpType = 167 + OpStructHeadNumberPtr OpType = 168 + OpStructHeadOmitEmptyNumberPtr OpType = 169 + OpStructPtrHeadNumberPtr OpType = 170 + OpStructPtrHeadOmitEmptyNumberPtr OpType = 171 + OpStructHeadArrayPtr OpType = 172 + OpStructHeadOmitEmptyArrayPtr OpType = 173 + OpStructPtrHeadArrayPtr OpType = 174 + OpStructPtrHeadOmitEmptyArrayPtr OpType = 175 + OpStructHeadMapPtr OpType = 176 + OpStructHeadOmitEmptyMapPtr OpType = 177 + OpStructPtrHeadMapPtr OpType = 178 + OpStructPtrHeadOmitEmptyMapPtr OpType = 179 + OpStructHeadSlicePtr OpType = 180 + OpStructHeadOmitEmptySlicePtr OpType = 181 + OpStructPtrHeadSlicePtr OpType = 182 + OpStructPtrHeadOmitEmptySlicePtr OpType = 183 + OpStructHeadMarshalJSONPtr OpType = 184 + OpStructHeadOmitEmptyMarshalJSONPtr OpType = 185 + OpStructPtrHeadMarshalJSONPtr OpType = 186 + OpStructPtrHeadOmitEmptyMarshalJSONPtr OpType = 187 + OpStructHeadMarshalTextPtr OpType = 188 + OpStructHeadOmitEmptyMarshalTextPtr OpType = 189 + OpStructPtrHeadMarshalTextPtr OpType = 190 + OpStructPtrHeadOmitEmptyMarshalTextPtr OpType = 191 + OpStructHeadInterfacePtr OpType = 192 + OpStructHeadOmitEmptyInterfacePtr OpType = 193 + OpStructPtrHeadInterfacePtr OpType = 194 + OpStructPtrHeadOmitEmptyInterfacePtr OpType = 195 + OpStructHeadIntPtrString OpType = 196 + OpStructHeadOmitEmptyIntPtrString OpType = 197 + OpStructPtrHeadIntPtrString OpType = 198 + OpStructPtrHeadOmitEmptyIntPtrString OpType = 199 + OpStructHeadUintPtrString OpType = 200 + OpStructHeadOmitEmptyUintPtrString OpType = 201 + OpStructPtrHeadUintPtrString OpType = 202 + OpStructPtrHeadOmitEmptyUintPtrString OpType = 203 + OpStructHeadFloat32PtrString OpType = 204 + OpStructHeadOmitEmptyFloat32PtrString OpType = 205 + OpStructPtrHeadFloat32PtrString OpType = 206 + OpStructPtrHeadOmitEmptyFloat32PtrString OpType = 207 + OpStructHeadFloat64PtrString OpType = 208 + OpStructHeadOmitEmptyFloat64PtrString OpType = 209 + OpStructPtrHeadFloat64PtrString OpType = 210 + OpStructPtrHeadOmitEmptyFloat64PtrString OpType = 211 + OpStructHeadBoolPtrString OpType = 212 + OpStructHeadOmitEmptyBoolPtrString OpType = 213 + OpStructPtrHeadBoolPtrString OpType = 214 + OpStructPtrHeadOmitEmptyBoolPtrString OpType = 215 + OpStructHeadStringPtrString OpType = 216 + OpStructHeadOmitEmptyStringPtrString OpType = 217 + OpStructPtrHeadStringPtrString OpType = 218 + OpStructPtrHeadOmitEmptyStringPtrString OpType = 219 + OpStructHeadNumberPtrString OpType = 220 + OpStructHeadOmitEmptyNumberPtrString OpType = 221 + OpStructPtrHeadNumberPtrString OpType = 222 + OpStructPtrHeadOmitEmptyNumberPtrString OpType = 223 + OpStructHead OpType = 224 + OpStructHeadOmitEmpty OpType = 225 + OpStructPtrHead OpType = 226 + OpStructPtrHeadOmitEmpty OpType = 227 + OpStructFieldInt OpType = 228 + OpStructFieldOmitEmptyInt OpType = 229 + OpStructEndInt OpType = 230 + OpStructEndOmitEmptyInt OpType = 231 + OpStructFieldUint OpType = 232 + OpStructFieldOmitEmptyUint OpType = 233 + OpStructEndUint OpType = 234 + OpStructEndOmitEmptyUint OpType = 235 + OpStructFieldFloat32 OpType = 236 + OpStructFieldOmitEmptyFloat32 OpType = 237 + OpStructEndFloat32 OpType = 238 + OpStructEndOmitEmptyFloat32 OpType = 239 + OpStructFieldFloat64 OpType = 240 + OpStructFieldOmitEmptyFloat64 OpType = 241 + OpStructEndFloat64 OpType = 242 + OpStructEndOmitEmptyFloat64 OpType = 243 + OpStructFieldBool OpType = 244 + OpStructFieldOmitEmptyBool OpType = 245 + OpStructEndBool OpType = 246 + OpStructEndOmitEmptyBool OpType = 247 + OpStructFieldString OpType = 248 + OpStructFieldOmitEmptyString OpType = 249 + OpStructEndString OpType = 250 + OpStructEndOmitEmptyString OpType = 251 + OpStructFieldBytes OpType = 252 + OpStructFieldOmitEmptyBytes OpType = 253 + OpStructEndBytes OpType = 254 + OpStructEndOmitEmptyBytes OpType = 255 + OpStructFieldNumber OpType = 256 + OpStructFieldOmitEmptyNumber OpType = 257 + OpStructEndNumber OpType = 258 + OpStructEndOmitEmptyNumber OpType = 259 + OpStructFieldArray OpType = 260 + OpStructFieldOmitEmptyArray OpType = 261 + OpStructEndArray OpType = 262 + OpStructEndOmitEmptyArray OpType = 263 + OpStructFieldMap OpType = 264 + OpStructFieldOmitEmptyMap OpType = 265 + OpStructEndMap OpType = 266 + OpStructEndOmitEmptyMap OpType = 267 + OpStructFieldSlice OpType = 268 + OpStructFieldOmitEmptySlice OpType = 269 + OpStructEndSlice OpType = 270 + OpStructEndOmitEmptySlice OpType = 271 + OpStructFieldStruct OpType = 272 + OpStructFieldOmitEmptyStruct OpType = 273 + OpStructEndStruct OpType = 274 + OpStructEndOmitEmptyStruct OpType = 275 + OpStructFieldMarshalJSON OpType = 276 + OpStructFieldOmitEmptyMarshalJSON OpType = 277 + OpStructEndMarshalJSON OpType = 278 + OpStructEndOmitEmptyMarshalJSON OpType = 279 + OpStructFieldMarshalText OpType = 280 + OpStructFieldOmitEmptyMarshalText OpType = 281 + OpStructEndMarshalText OpType = 282 + OpStructEndOmitEmptyMarshalText OpType = 283 + OpStructFieldIntString OpType = 284 + OpStructFieldOmitEmptyIntString OpType = 285 + OpStructEndIntString OpType = 286 + OpStructEndOmitEmptyIntString OpType = 287 + OpStructFieldUintString OpType = 288 + OpStructFieldOmitEmptyUintString OpType = 289 + OpStructEndUintString OpType = 290 + OpStructEndOmitEmptyUintString OpType = 291 + OpStructFieldFloat32String OpType = 292 + OpStructFieldOmitEmptyFloat32String OpType = 293 + OpStructEndFloat32String OpType = 294 + OpStructEndOmitEmptyFloat32String OpType = 295 + OpStructFieldFloat64String OpType = 296 + OpStructFieldOmitEmptyFloat64String OpType = 297 + OpStructEndFloat64String OpType = 298 + OpStructEndOmitEmptyFloat64String OpType = 299 + OpStructFieldBoolString OpType = 300 + OpStructFieldOmitEmptyBoolString OpType = 301 + OpStructEndBoolString OpType = 302 + OpStructEndOmitEmptyBoolString OpType = 303 + OpStructFieldStringString OpType = 304 + OpStructFieldOmitEmptyStringString OpType = 305 + OpStructEndStringString OpType = 306 + OpStructEndOmitEmptyStringString OpType = 307 + OpStructFieldNumberString OpType = 308 + OpStructFieldOmitEmptyNumberString OpType = 309 + OpStructEndNumberString OpType = 310 + OpStructEndOmitEmptyNumberString OpType = 311 + OpStructFieldIntPtr OpType = 312 + OpStructFieldOmitEmptyIntPtr OpType = 313 + OpStructEndIntPtr OpType = 314 + OpStructEndOmitEmptyIntPtr OpType = 315 + OpStructFieldUintPtr OpType = 316 + OpStructFieldOmitEmptyUintPtr OpType = 317 + OpStructEndUintPtr OpType = 318 + OpStructEndOmitEmptyUintPtr OpType = 319 + OpStructFieldFloat32Ptr OpType = 320 + OpStructFieldOmitEmptyFloat32Ptr OpType = 321 + OpStructEndFloat32Ptr OpType = 322 + OpStructEndOmitEmptyFloat32Ptr OpType = 323 + OpStructFieldFloat64Ptr OpType = 324 + OpStructFieldOmitEmptyFloat64Ptr OpType = 325 + OpStructEndFloat64Ptr OpType = 326 + OpStructEndOmitEmptyFloat64Ptr OpType = 327 + OpStructFieldBoolPtr OpType = 328 + OpStructFieldOmitEmptyBoolPtr OpType = 329 + OpStructEndBoolPtr OpType = 330 + OpStructEndOmitEmptyBoolPtr OpType = 331 + OpStructFieldStringPtr OpType = 332 + OpStructFieldOmitEmptyStringPtr OpType = 333 + OpStructEndStringPtr OpType = 334 + OpStructEndOmitEmptyStringPtr OpType = 335 + OpStructFieldBytesPtr OpType = 336 + OpStructFieldOmitEmptyBytesPtr OpType = 337 + OpStructEndBytesPtr OpType = 338 + OpStructEndOmitEmptyBytesPtr OpType = 339 + OpStructFieldNumberPtr OpType = 340 + OpStructFieldOmitEmptyNumberPtr OpType = 341 + OpStructEndNumberPtr OpType = 342 + OpStructEndOmitEmptyNumberPtr OpType = 343 + OpStructFieldArrayPtr OpType = 344 + OpStructFieldOmitEmptyArrayPtr OpType = 345 + OpStructEndArrayPtr OpType = 346 + OpStructEndOmitEmptyArrayPtr OpType = 347 + OpStructFieldMapPtr OpType = 348 + OpStructFieldOmitEmptyMapPtr OpType = 349 + OpStructEndMapPtr OpType = 350 + OpStructEndOmitEmptyMapPtr OpType = 351 + OpStructFieldSlicePtr OpType = 352 + OpStructFieldOmitEmptySlicePtr OpType = 353 + OpStructEndSlicePtr OpType = 354 + OpStructEndOmitEmptySlicePtr OpType = 355 + OpStructFieldMarshalJSONPtr OpType = 356 + OpStructFieldOmitEmptyMarshalJSONPtr OpType = 357 + OpStructEndMarshalJSONPtr OpType = 358 + OpStructEndOmitEmptyMarshalJSONPtr OpType = 359 + OpStructFieldMarshalTextPtr OpType = 360 + OpStructFieldOmitEmptyMarshalTextPtr OpType = 361 + OpStructEndMarshalTextPtr OpType = 362 + OpStructEndOmitEmptyMarshalTextPtr OpType = 363 + OpStructFieldInterfacePtr OpType = 364 + OpStructFieldOmitEmptyInterfacePtr OpType = 365 + OpStructEndInterfacePtr OpType = 366 + OpStructEndOmitEmptyInterfacePtr OpType = 367 + OpStructFieldIntPtrString OpType = 368 + OpStructFieldOmitEmptyIntPtrString OpType = 369 + OpStructEndIntPtrString OpType = 370 + OpStructEndOmitEmptyIntPtrString OpType = 371 + OpStructFieldUintPtrString OpType = 372 + OpStructFieldOmitEmptyUintPtrString OpType = 373 + OpStructEndUintPtrString OpType = 374 + OpStructEndOmitEmptyUintPtrString OpType = 375 + OpStructFieldFloat32PtrString OpType = 376 + OpStructFieldOmitEmptyFloat32PtrString OpType = 377 + OpStructEndFloat32PtrString OpType = 378 + OpStructEndOmitEmptyFloat32PtrString OpType = 379 + OpStructFieldFloat64PtrString OpType = 380 + OpStructFieldOmitEmptyFloat64PtrString OpType = 381 + OpStructEndFloat64PtrString OpType = 382 + OpStructEndOmitEmptyFloat64PtrString OpType = 383 + OpStructFieldBoolPtrString OpType = 384 + OpStructFieldOmitEmptyBoolPtrString OpType = 385 + OpStructEndBoolPtrString OpType = 386 + OpStructEndOmitEmptyBoolPtrString OpType = 387 + OpStructFieldStringPtrString OpType = 388 + OpStructFieldOmitEmptyStringPtrString OpType = 389 + OpStructEndStringPtrString OpType = 390 + OpStructEndOmitEmptyStringPtrString OpType = 391 + OpStructFieldNumberPtrString OpType = 392 + OpStructFieldOmitEmptyNumberPtrString OpType = 393 + OpStructEndNumberPtrString OpType = 394 + OpStructEndOmitEmptyNumberPtrString OpType = 395 + OpStructField OpType = 396 + OpStructFieldOmitEmpty OpType = 397 + OpStructEnd OpType = 398 + OpStructEndOmitEmpty OpType = 399 +) + +func (t OpType) String() string { + if int(t) >= 400 { + return "" + } + return opTypeStrings[int(t)] +} + +func (t OpType) CodeType() CodeType { + if strings.Contains(t.String(), "Struct") { + if strings.Contains(t.String(), "End") { + return CodeStructEnd + } + return CodeStructField + } + switch t { + case OpArray, OpArrayPtr: + return CodeArrayHead + case OpArrayElem: + return CodeArrayElem + case OpSlice, OpSlicePtr: + return CodeSliceHead + case OpSliceElem: + return CodeSliceElem + case OpMap, OpMapPtr: + return CodeMapHead + case OpMapKey: + return CodeMapKey + case OpMapValue: + return CodeMapValue + case OpMapEnd: + return CodeMapEnd + } + + return CodeOp +} + +func (t OpType) HeadToPtrHead() OpType { + if strings.Index(t.String(), "PtrHead") > 0 { + return t + } + + idx := strings.Index(t.String(), "Head") + if idx == -1 { + return t + } + suffix := "PtrHead" + t.String()[idx+len("Head"):] + + const toPtrOffset = 2 + if strings.Contains(OpType(int(t)+toPtrOffset).String(), suffix) { + return OpType(int(t) + toPtrOffset) + } + return t +} + +func (t OpType) HeadToOmitEmptyHead() OpType { + const toOmitEmptyOffset = 1 + if strings.Contains(OpType(int(t)+toOmitEmptyOffset).String(), "OmitEmpty") { + return OpType(int(t) + toOmitEmptyOffset) + } + + return t +} + +func (t OpType) PtrHeadToHead() OpType { + idx := strings.Index(t.String(), "PtrHead") + if idx == -1 { + return t + } + suffix := t.String()[idx+len("Ptr"):] + + const toPtrOffset = 2 + if strings.Contains(OpType(int(t)-toPtrOffset).String(), suffix) { + return OpType(int(t) - toPtrOffset) + } + return t +} + +func (t OpType) FieldToEnd() OpType { + idx := strings.Index(t.String(), "Field") + if idx == -1 { + return t + } + suffix := t.String()[idx+len("Field"):] + if suffix == "" || suffix == "OmitEmpty" { + return t + } + const toEndOffset = 2 + if strings.Contains(OpType(int(t)+toEndOffset).String(), "End"+suffix) { + return OpType(int(t) + toEndOffset) + } + return t +} + +func (t OpType) FieldToOmitEmptyField() OpType { + const toOmitEmptyOffset = 1 + if strings.Contains(OpType(int(t)+toOmitEmptyOffset).String(), "OmitEmpty") { + return OpType(int(t) + toOmitEmptyOffset) + } + return t +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/query.go b/vendor/github.com/goccy/go-json/internal/encoder/query.go new file mode 100644 index 00000000..1e1850cc --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/query.go @@ -0,0 +1,135 @@ +package encoder + +import ( + "context" + "fmt" + "reflect" +) + +var ( + Marshal func(interface{}) ([]byte, error) + Unmarshal func([]byte, interface{}) error +) + +type FieldQuery struct { + Name string + Fields []*FieldQuery + hash string +} + +func (q *FieldQuery) Hash() string { + if q.hash != "" { + return q.hash + } + b, _ := Marshal(q) + q.hash = string(b) + return q.hash +} + +func (q *FieldQuery) MarshalJSON() ([]byte, error) { + if q.Name != "" { + if len(q.Fields) > 0 { + return Marshal(map[string][]*FieldQuery{q.Name: q.Fields}) + } + return Marshal(q.Name) + } + return Marshal(q.Fields) +} + +func (q *FieldQuery) QueryString() (FieldQueryString, error) { + b, err := Marshal(q) + if err != nil { + return "", err + } + return FieldQueryString(b), nil +} + +type FieldQueryString string + +func (s FieldQueryString) Build() (*FieldQuery, error) { + var query interface{} + if err := Unmarshal([]byte(s), &query); err != nil { + return nil, err + } + return s.build(reflect.ValueOf(query)) +} + +func (s FieldQueryString) build(v reflect.Value) (*FieldQuery, error) { + switch v.Type().Kind() { + case reflect.String: + return s.buildString(v) + case reflect.Map: + return s.buildMap(v) + case reflect.Slice: + return s.buildSlice(v) + case reflect.Interface: + return s.build(reflect.ValueOf(v.Interface())) + } + return nil, fmt.Errorf("failed to build field query") +} + +func (s FieldQueryString) buildString(v reflect.Value) (*FieldQuery, error) { + b := []byte(v.String()) + switch b[0] { + case '[', '{': + var query interface{} + if err := Unmarshal(b, &query); err != nil { + return nil, err + } + if str, ok := query.(string); ok { + return &FieldQuery{Name: str}, nil + } + return s.build(reflect.ValueOf(query)) + } + return &FieldQuery{Name: string(b)}, nil +} + +func (s FieldQueryString) buildSlice(v reflect.Value) (*FieldQuery, error) { + fields := make([]*FieldQuery, 0, v.Len()) + for i := 0; i < v.Len(); i++ { + def, err := s.build(v.Index(i)) + if err != nil { + return nil, err + } + fields = append(fields, def) + } + return &FieldQuery{Fields: fields}, nil +} + +func (s FieldQueryString) buildMap(v reflect.Value) (*FieldQuery, error) { + keys := v.MapKeys() + if len(keys) != 1 { + return nil, fmt.Errorf("failed to build field query object") + } + key := keys[0] + if key.Type().Kind() != reflect.String { + return nil, fmt.Errorf("failed to build field query. invalid object key type") + } + name := key.String() + def, err := s.build(v.MapIndex(key)) + if err != nil { + return nil, err + } + return &FieldQuery{ + Name: name, + Fields: def.Fields, + }, nil +} + +type queryKey struct{} + +func FieldQueryFromContext(ctx context.Context) *FieldQuery { + query := ctx.Value(queryKey{}) + if query == nil { + return nil + } + q, ok := query.(*FieldQuery) + if !ok { + return nil + } + return q +} + +func SetFieldQueryToContext(ctx context.Context, query *FieldQuery) context.Context { + return context.WithValue(ctx, queryKey{}, query) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string.go b/vendor/github.com/goccy/go-json/internal/encoder/string.go new file mode 100644 index 00000000..4abb8416 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/string.go @@ -0,0 +1,483 @@ +// This files's string processing codes are inspired by https://github.com/segmentio/encoding. +// The license notation is as follows. +// +// # MIT License +// +// Copyright (c) 2019 Segment.io, Inc. +// +// 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. +package encoder + +import ( + "math/bits" + "reflect" + "unsafe" +) + +const ( + lsb = 0x0101010101010101 + msb = 0x8080808080808080 +) + +var hex = "0123456789abcdef" + +//nolint:govet +func stringToUint64Slice(s string) []uint64 { + return *(*[]uint64)(unsafe.Pointer(&reflect.SliceHeader{ + Data: ((*reflect.StringHeader)(unsafe.Pointer(&s))).Data, + Len: len(s) / 8, + Cap: len(s) / 8, + })) +} + +func AppendString(ctx *RuntimeContext, buf []byte, s string) []byte { + if ctx.Option.Flag&HTMLEscapeOption != 0 { + if ctx.Option.Flag&NormalizeUTF8Option != 0 { + return appendNormalizedHTMLString(buf, s) + } + return appendHTMLString(buf, s) + } + if ctx.Option.Flag&NormalizeUTF8Option != 0 { + return appendNormalizedString(buf, s) + } + return appendString(buf, s) +} + +func appendNormalizedHTMLString(buf []byte, s string) []byte { + valLen := len(s) + if valLen == 0 { + return append(buf, `""`...) + } + buf = append(buf, '"') + var ( + i, j int + ) + if valLen >= 8 { + chunks := stringToUint64Slice(s) + for _, n := range chunks { + // combine masks before checking for the MSB of each byte. We include + // `n` in the mask to check whether any of the *input* byte MSBs were + // set (i.e. the byte was outside the ASCII range). + mask := n | (n - (lsb * 0x20)) | + ((n ^ (lsb * '"')) - lsb) | + ((n ^ (lsb * '\\')) - lsb) | + ((n ^ (lsb * '<')) - lsb) | + ((n ^ (lsb * '>')) - lsb) | + ((n ^ (lsb * '&')) - lsb) + if (mask & msb) != 0 { + j = bits.TrailingZeros64(mask&msb) / 8 + goto ESCAPE_END + } + } + for i := len(chunks) * 8; i < valLen; i++ { + if needEscapeHTMLNormalizeUTF8[s[i]] { + j = i + goto ESCAPE_END + } + } + // no found any escape characters. + return append(append(buf, s...), '"') + } +ESCAPE_END: + for j < valLen { + c := s[j] + + if !needEscapeHTMLNormalizeUTF8[c] { + // fast path: most of the time, printable ascii characters are used + j++ + continue + } + + switch c { + case '\\', '"': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', c) + i = j + 1 + j = j + 1 + continue + + case '\n': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'n') + i = j + 1 + j = j + 1 + continue + + case '\r': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'r') + i = j + 1 + j = j + 1 + continue + + case '\t': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 't') + i = j + 1 + j = j + 1 + continue + + case '<', '>', '&': + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + + case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + } + state, size := decodeRuneInString(s[j:]) + switch state { + case runeErrorState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\ufffd`...) + i = j + 1 + j = j + 1 + continue + // U+2028 is LINE SEPARATOR. + // U+2029 is PARAGRAPH SEPARATOR. + // They are both technically valid characters in JSON strings, + // but don't work in JSONP, which has to be evaluated as JavaScript, + // and can lead to security holes there. It is valid JSON to + // escape them, so we do so unconditionally. + // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion. + case lineSepState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\u2028`...) + i = j + 3 + j = j + 3 + continue + case paragraphSepState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\u2029`...) + i = j + 3 + j = j + 3 + continue + } + j += size + } + + return append(append(buf, s[i:]...), '"') +} + +func appendHTMLString(buf []byte, s string) []byte { + valLen := len(s) + if valLen == 0 { + return append(buf, `""`...) + } + buf = append(buf, '"') + var ( + i, j int + ) + if valLen >= 8 { + chunks := stringToUint64Slice(s) + for _, n := range chunks { + // combine masks before checking for the MSB of each byte. We include + // `n` in the mask to check whether any of the *input* byte MSBs were + // set (i.e. the byte was outside the ASCII range). + mask := n | (n - (lsb * 0x20)) | + ((n ^ (lsb * '"')) - lsb) | + ((n ^ (lsb * '\\')) - lsb) | + ((n ^ (lsb * '<')) - lsb) | + ((n ^ (lsb * '>')) - lsb) | + ((n ^ (lsb * '&')) - lsb) + if (mask & msb) != 0 { + j = bits.TrailingZeros64(mask&msb) / 8 + goto ESCAPE_END + } + } + for i := len(chunks) * 8; i < valLen; i++ { + if needEscapeHTML[s[i]] { + j = i + goto ESCAPE_END + } + } + // no found any escape characters. + return append(append(buf, s...), '"') + } +ESCAPE_END: + for j < valLen { + c := s[j] + + if !needEscapeHTML[c] { + // fast path: most of the time, printable ascii characters are used + j++ + continue + } + + switch c { + case '\\', '"': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', c) + i = j + 1 + j = j + 1 + continue + + case '\n': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'n') + i = j + 1 + j = j + 1 + continue + + case '\r': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'r') + i = j + 1 + j = j + 1 + continue + + case '\t': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 't') + i = j + 1 + j = j + 1 + continue + + case '<', '>', '&': + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + + case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + } + j++ + } + + return append(append(buf, s[i:]...), '"') +} + +func appendNormalizedString(buf []byte, s string) []byte { + valLen := len(s) + if valLen == 0 { + return append(buf, `""`...) + } + buf = append(buf, '"') + var ( + i, j int + ) + if valLen >= 8 { + chunks := stringToUint64Slice(s) + for _, n := range chunks { + // combine masks before checking for the MSB of each byte. We include + // `n` in the mask to check whether any of the *input* byte MSBs were + // set (i.e. the byte was outside the ASCII range). + mask := n | (n - (lsb * 0x20)) | + ((n ^ (lsb * '"')) - lsb) | + ((n ^ (lsb * '\\')) - lsb) + if (mask & msb) != 0 { + j = bits.TrailingZeros64(mask&msb) / 8 + goto ESCAPE_END + } + } + valLen := len(s) + for i := len(chunks) * 8; i < valLen; i++ { + if needEscapeNormalizeUTF8[s[i]] { + j = i + goto ESCAPE_END + } + } + return append(append(buf, s...), '"') + } +ESCAPE_END: + for j < valLen { + c := s[j] + + if !needEscapeNormalizeUTF8[c] { + // fast path: most of the time, printable ascii characters are used + j++ + continue + } + + switch c { + case '\\', '"': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', c) + i = j + 1 + j = j + 1 + continue + + case '\n': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'n') + i = j + 1 + j = j + 1 + continue + + case '\r': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'r') + i = j + 1 + j = j + 1 + continue + + case '\t': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 't') + i = j + 1 + j = j + 1 + continue + + case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + } + + state, size := decodeRuneInString(s[j:]) + switch state { + case runeErrorState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\ufffd`...) + i = j + 1 + j = j + 1 + continue + // U+2028 is LINE SEPARATOR. + // U+2029 is PARAGRAPH SEPARATOR. + // They are both technically valid characters in JSON strings, + // but don't work in JSONP, which has to be evaluated as JavaScript, + // and can lead to security holes there. It is valid JSON to + // escape them, so we do so unconditionally. + // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion. + case lineSepState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\u2028`...) + i = j + 3 + j = j + 3 + continue + case paragraphSepState: + buf = append(buf, s[i:j]...) + buf = append(buf, `\u2029`...) + i = j + 3 + j = j + 3 + continue + } + j += size + } + + return append(append(buf, s[i:]...), '"') +} + +func appendString(buf []byte, s string) []byte { + valLen := len(s) + if valLen == 0 { + return append(buf, `""`...) + } + buf = append(buf, '"') + var ( + i, j int + ) + if valLen >= 8 { + chunks := stringToUint64Slice(s) + for _, n := range chunks { + // combine masks before checking for the MSB of each byte. We include + // `n` in the mask to check whether any of the *input* byte MSBs were + // set (i.e. the byte was outside the ASCII range). + mask := n | (n - (lsb * 0x20)) | + ((n ^ (lsb * '"')) - lsb) | + ((n ^ (lsb * '\\')) - lsb) + if (mask & msb) != 0 { + j = bits.TrailingZeros64(mask&msb) / 8 + goto ESCAPE_END + } + } + valLen := len(s) + for i := len(chunks) * 8; i < valLen; i++ { + if needEscape[s[i]] { + j = i + goto ESCAPE_END + } + } + return append(append(buf, s...), '"') + } +ESCAPE_END: + for j < valLen { + c := s[j] + + if !needEscape[c] { + // fast path: most of the time, printable ascii characters are used + j++ + continue + } + + switch c { + case '\\', '"': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', c) + i = j + 1 + j = j + 1 + continue + + case '\n': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'n') + i = j + 1 + j = j + 1 + continue + + case '\r': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 'r') + i = j + 1 + j = j + 1 + continue + + case '\t': + buf = append(buf, s[i:j]...) + buf = append(buf, '\\', 't') + i = j + 1 + j = j + 1 + continue + + case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F + buf = append(buf, s[i:j]...) + buf = append(buf, `\u00`...) + buf = append(buf, hex[c>>4], hex[c&0xF]) + i = j + 1 + j = j + 1 + continue + } + j++ + } + + return append(append(buf, s[i:]...), '"') +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string_table.go b/vendor/github.com/goccy/go-json/internal/encoder/string_table.go new file mode 100644 index 00000000..ebe42c92 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/string_table.go @@ -0,0 +1,415 @@ +package encoder + +var needEscapeHTMLNormalizeUTF8 = [256]bool{ + '"': true, + '&': true, + '<': true, + '>': true, + '\\': true, + 0x00: true, + 0x01: true, + 0x02: true, + 0x03: true, + 0x04: true, + 0x05: true, + 0x06: true, + 0x07: true, + 0x08: true, + 0x09: true, + 0x0a: true, + 0x0b: true, + 0x0c: true, + 0x0d: true, + 0x0e: true, + 0x0f: true, + 0x10: true, + 0x11: true, + 0x12: true, + 0x13: true, + 0x14: true, + 0x15: true, + 0x16: true, + 0x17: true, + 0x18: true, + 0x19: true, + 0x1a: true, + 0x1b: true, + 0x1c: true, + 0x1d: true, + 0x1e: true, + 0x1f: true, + /* 0x20 - 0x7f */ + 0x80: true, + 0x81: true, + 0x82: true, + 0x83: true, + 0x84: true, + 0x85: true, + 0x86: true, + 0x87: true, + 0x88: true, + 0x89: true, + 0x8a: true, + 0x8b: true, + 0x8c: true, + 0x8d: true, + 0x8e: true, + 0x8f: true, + 0x90: true, + 0x91: true, + 0x92: true, + 0x93: true, + 0x94: true, + 0x95: true, + 0x96: true, + 0x97: true, + 0x98: true, + 0x99: true, + 0x9a: true, + 0x9b: true, + 0x9c: true, + 0x9d: true, + 0x9e: true, + 0x9f: true, + 0xa0: true, + 0xa1: true, + 0xa2: true, + 0xa3: true, + 0xa4: true, + 0xa5: true, + 0xa6: true, + 0xa7: true, + 0xa8: true, + 0xa9: true, + 0xaa: true, + 0xab: true, + 0xac: true, + 0xad: true, + 0xae: true, + 0xaf: true, + 0xb0: true, + 0xb1: true, + 0xb2: true, + 0xb3: true, + 0xb4: true, + 0xb5: true, + 0xb6: true, + 0xb7: true, + 0xb8: true, + 0xb9: true, + 0xba: true, + 0xbb: true, + 0xbc: true, + 0xbd: true, + 0xbe: true, + 0xbf: true, + 0xc0: true, + 0xc1: true, + 0xc2: true, + 0xc3: true, + 0xc4: true, + 0xc5: true, + 0xc6: true, + 0xc7: true, + 0xc8: true, + 0xc9: true, + 0xca: true, + 0xcb: true, + 0xcc: true, + 0xcd: true, + 0xce: true, + 0xcf: true, + 0xd0: true, + 0xd1: true, + 0xd2: true, + 0xd3: true, + 0xd4: true, + 0xd5: true, + 0xd6: true, + 0xd7: true, + 0xd8: true, + 0xd9: true, + 0xda: true, + 0xdb: true, + 0xdc: true, + 0xdd: true, + 0xde: true, + 0xdf: true, + 0xe0: true, + 0xe1: true, + 0xe2: true, + 0xe3: true, + 0xe4: true, + 0xe5: true, + 0xe6: true, + 0xe7: true, + 0xe8: true, + 0xe9: true, + 0xea: true, + 0xeb: true, + 0xec: true, + 0xed: true, + 0xee: true, + 0xef: true, + 0xf0: true, + 0xf1: true, + 0xf2: true, + 0xf3: true, + 0xf4: true, + 0xf5: true, + 0xf6: true, + 0xf7: true, + 0xf8: true, + 0xf9: true, + 0xfa: true, + 0xfb: true, + 0xfc: true, + 0xfd: true, + 0xfe: true, + 0xff: true, +} + +var needEscapeNormalizeUTF8 = [256]bool{ + '"': true, + '\\': true, + 0x00: true, + 0x01: true, + 0x02: true, + 0x03: true, + 0x04: true, + 0x05: true, + 0x06: true, + 0x07: true, + 0x08: true, + 0x09: true, + 0x0a: true, + 0x0b: true, + 0x0c: true, + 0x0d: true, + 0x0e: true, + 0x0f: true, + 0x10: true, + 0x11: true, + 0x12: true, + 0x13: true, + 0x14: true, + 0x15: true, + 0x16: true, + 0x17: true, + 0x18: true, + 0x19: true, + 0x1a: true, + 0x1b: true, + 0x1c: true, + 0x1d: true, + 0x1e: true, + 0x1f: true, + /* 0x20 - 0x7f */ + 0x80: true, + 0x81: true, + 0x82: true, + 0x83: true, + 0x84: true, + 0x85: true, + 0x86: true, + 0x87: true, + 0x88: true, + 0x89: true, + 0x8a: true, + 0x8b: true, + 0x8c: true, + 0x8d: true, + 0x8e: true, + 0x8f: true, + 0x90: true, + 0x91: true, + 0x92: true, + 0x93: true, + 0x94: true, + 0x95: true, + 0x96: true, + 0x97: true, + 0x98: true, + 0x99: true, + 0x9a: true, + 0x9b: true, + 0x9c: true, + 0x9d: true, + 0x9e: true, + 0x9f: true, + 0xa0: true, + 0xa1: true, + 0xa2: true, + 0xa3: true, + 0xa4: true, + 0xa5: true, + 0xa6: true, + 0xa7: true, + 0xa8: true, + 0xa9: true, + 0xaa: true, + 0xab: true, + 0xac: true, + 0xad: true, + 0xae: true, + 0xaf: true, + 0xb0: true, + 0xb1: true, + 0xb2: true, + 0xb3: true, + 0xb4: true, + 0xb5: true, + 0xb6: true, + 0xb7: true, + 0xb8: true, + 0xb9: true, + 0xba: true, + 0xbb: true, + 0xbc: true, + 0xbd: true, + 0xbe: true, + 0xbf: true, + 0xc0: true, + 0xc1: true, + 0xc2: true, + 0xc3: true, + 0xc4: true, + 0xc5: true, + 0xc6: true, + 0xc7: true, + 0xc8: true, + 0xc9: true, + 0xca: true, + 0xcb: true, + 0xcc: true, + 0xcd: true, + 0xce: true, + 0xcf: true, + 0xd0: true, + 0xd1: true, + 0xd2: true, + 0xd3: true, + 0xd4: true, + 0xd5: true, + 0xd6: true, + 0xd7: true, + 0xd8: true, + 0xd9: true, + 0xda: true, + 0xdb: true, + 0xdc: true, + 0xdd: true, + 0xde: true, + 0xdf: true, + 0xe0: true, + 0xe1: true, + 0xe2: true, + 0xe3: true, + 0xe4: true, + 0xe5: true, + 0xe6: true, + 0xe7: true, + 0xe8: true, + 0xe9: true, + 0xea: true, + 0xeb: true, + 0xec: true, + 0xed: true, + 0xee: true, + 0xef: true, + 0xf0: true, + 0xf1: true, + 0xf2: true, + 0xf3: true, + 0xf4: true, + 0xf5: true, + 0xf6: true, + 0xf7: true, + 0xf8: true, + 0xf9: true, + 0xfa: true, + 0xfb: true, + 0xfc: true, + 0xfd: true, + 0xfe: true, + 0xff: true, +} + +var needEscapeHTML = [256]bool{ + '"': true, + '&': true, + '<': true, + '>': true, + '\\': true, + 0x00: true, + 0x01: true, + 0x02: true, + 0x03: true, + 0x04: true, + 0x05: true, + 0x06: true, + 0x07: true, + 0x08: true, + 0x09: true, + 0x0a: true, + 0x0b: true, + 0x0c: true, + 0x0d: true, + 0x0e: true, + 0x0f: true, + 0x10: true, + 0x11: true, + 0x12: true, + 0x13: true, + 0x14: true, + 0x15: true, + 0x16: true, + 0x17: true, + 0x18: true, + 0x19: true, + 0x1a: true, + 0x1b: true, + 0x1c: true, + 0x1d: true, + 0x1e: true, + 0x1f: true, + /* 0x20 - 0xff */ +} + +var needEscape = [256]bool{ + '"': true, + '\\': true, + 0x00: true, + 0x01: true, + 0x02: true, + 0x03: true, + 0x04: true, + 0x05: true, + 0x06: true, + 0x07: true, + 0x08: true, + 0x09: true, + 0x0a: true, + 0x0b: true, + 0x0c: true, + 0x0d: true, + 0x0e: true, + 0x0f: true, + 0x10: true, + 0x11: true, + 0x12: true, + 0x13: true, + 0x14: true, + 0x15: true, + 0x16: true, + 0x17: true, + 0x18: true, + 0x19: true, + 0x1a: true, + 0x1b: true, + 0x1c: true, + 0x1d: true, + 0x1e: true, + 0x1f: true, + /* 0x20 - 0xff */ +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go new file mode 100644 index 00000000..82b6dd47 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go @@ -0,0 +1,41 @@ +package vm + +import ( + "fmt" + "io" + + "github.com/goccy/go-json/internal/encoder" +) + +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + defer func() { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + if wc := ctx.Option.DebugDOTOut; wc != nil { + _, _ = io.WriteString(wc, code.DumpDOT()) + wc.Close() + ctx.Option.DebugDOTOut = nil + } + + if err := recover(); err != nil { + w := ctx.Option.DebugOut + fmt.Fprintln(w, "=============[DEBUG]===============") + fmt.Fprintln(w, "* [TYPE]") + fmt.Fprintln(w, codeSet.Type) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [ALL OPCODE]") + fmt.Fprintln(w, code.Dump()) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [CONTEXT]") + fmt.Fprintf(w, "%+v\n", ctx) + fmt.Fprintln(w, "===================================") + panic(err) + } + }() + + return Run(ctx, b, codeSet) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go new file mode 100644 index 00000000..65252b4a --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go @@ -0,0 +1,9 @@ +package vm + +import ( + // HACK: compile order + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, + // so forcibly make dependencies and avoid compiling in concurrent. + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_indent" +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go new file mode 100644 index 00000000..86291d7b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go @@ -0,0 +1,207 @@ +package vm + +import ( + "encoding/json" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +const uintptrSize = 4 << (^uintptr(0) >> 63) + +var ( + appendInt = encoder.AppendInt + appendUint = encoder.AppendUint + appendFloat32 = encoder.AppendFloat32 + appendFloat64 = encoder.AppendFloat64 + appendString = encoder.AppendString + appendByteSlice = encoder.AppendByteSlice + appendNumber = encoder.AppendNumber + errUnsupportedValue = encoder.ErrUnsupportedValue + errUnsupportedFloat = encoder.ErrUnsupportedFloat + mapiterinit = encoder.MapIterInit + mapiterkey = encoder.MapIterKey + mapitervalue = encoder.MapIterValue + mapiternext = encoder.MapIterNext + maplen = encoder.MapLen +) + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + +func errUnimplementedOp(op encoder.OpType) error { + return fmt.Errorf("encoder: opcode %s has not been implemented", op) +} + +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) + return **(**uintptr)(unsafe.Pointer(&addr)) +} + +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) + **(**uintptr)(unsafe.Pointer(&addr)) = p +} + +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) + p := **(**uintptr)(unsafe.Pointer(&addr)) + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUint64(p uintptr, bitSize uint8) uint64 { + switch bitSize { + case 8: + return (uint64)(**(**uint8)(unsafe.Pointer(&p))) + case 16: + return (uint64)(**(**uint16)(unsafe.Pointer(&p))) + case 32: + return (uint64)(**(**uint32)(unsafe.Pointer(&p))) + case 64: + return **(**uint64)(unsafe.Pointer(&p)) + } + return 0 +} +func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) } +func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) } +func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) } +func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) } +func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) } +func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) } +func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) } +func ptrToPtr(p uintptr) uintptr { + return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p))) +} +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUnsafePtr(p uintptr) unsafe.Pointer { + return *(*unsafe.Pointer)(unsafe.Pointer(&p)) +} +func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { + return *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) +} + +func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte { + if v { + return append(b, "true"...) + } + return append(b, "false"...) +} + +func appendNull(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, "null"...) +} + +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ',') +} + +func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, "null,"...) +} + +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { + last := len(b) - 1 + b[last] = ':' + return b +} + +func appendMapKeyValue(_ *encoder.RuntimeContext, _ *encoder.Opcode, b, key, value []byte) []byte { + b = append(b, key...) + b[len(b)-1] = ':' + return append(b, value...) +} + +func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + b[len(b)-1] = '}' + b = append(b, ',') + return b +} + +func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalJSON(ctx, code, b, v) +} + +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalText(ctx, code, b, v) +} + +func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + return append(b, '[') +} + +func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + b[last] = ']' + return append(b, ',') +} + +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '[', ']', ',') +} + +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '}', ',') +} + +func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + b[last] = '}' + return append(b, ',') +} + +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{') +} + +func appendStructKey(_ *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + return append(b, code.Key...) +} + +func appendStructEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + return append(b, '}', ',') +} + +func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + if b[last] == ',' { + b[last] = '}' + return appendComma(ctx, b) + } + return appendStructEnd(ctx, code, b) +} + +func restoreIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, _ uintptr) {} +func storeIndent(_ uintptr, _ *encoder.Opcode, _ uintptr) {} +func appendMapKeyIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b } +func appendArrayElemIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go new file mode 100644 index 00000000..645d20f9 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go @@ -0,0 +1,4859 @@ +// Code generated by internal/cmd/generator. DO NOT EDIT! +package vm + +import ( + "math" + "reflect" + "sort" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + recursiveLevel := 0 + ptrOffset := uintptr(0) + ctxptr := ctx.Ptr() + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + for { + switch code.Op { + default: + return nil, errUnimplementedOp(code.Op) + case encoder.OpPtr: + p := load(ctxptr, code.Idx) + code = code.Next + store(ctxptr, code.Idx, ptrToPtr(p)) + case encoder.OpIntPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInt: + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpUint: + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpIntString: + b = append(b, '"') + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintString: + b = append(b, '"') + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat32Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat32: + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat64Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat64: + v := ptrToFloat64(load(ctxptr, code.Idx)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStringPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpString: + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBoolPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBool: + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBytesPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBytes: + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpNumberPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpNumber: + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpInterfacePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInterface: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, p) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + if iface.itab != nil { + typ = iface.itab.typ + } + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ) + if !isDirectedNil { + b = appendNullComma(ctx, b) + code = code.Next + break + } + } + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ))) + if err != nil { + return nil, err + } + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + ctx.BaseIndent += code.Indent + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + b = append(b, `""`...) + b = appendComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpSlicePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpSlice: + p := load(ctxptr, code.Idx) + slice := ptrToSlice(p) + if p == 0 || slice.Data == nil { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.ElemIdx, 0) + store(ctxptr, code.Length, uintptr(slice.Len)) + store(ctxptr, code.Idx, uintptr(slice.Data)) + if slice.Len > 0 { + b = appendArrayHead(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, uintptr(slice.Data)) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpSliceElem: + idx := load(ctxptr, code.ElemIdx) + length := load(ctxptr, code.Length) + idx++ + if idx < length { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, data+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpArrayPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpArray: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + if code.Length > 0 { + b = appendArrayHead(ctx, code, b) + store(ctxptr, code.ElemIdx, 0) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpArrayElem: + idx := load(ctxptr, code.ElemIdx) + idx++ + if idx < uintptr(code.Length) { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, p+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpMapPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpMap: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + uptr := ptrToUnsafePtr(p) + mlen := maplen(uptr) + if mlen <= 0 { + b = appendEmptyObject(ctx, b) + code = code.End.Next + break + } + b = appendStructHead(ctx, b) + unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 + mapCtx := encoder.NewMapContext(mlen, unorderedMap) + mapiterinit(code.Type, uptr, &mapCtx.Iter) + store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx))) + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) + if unorderedMap { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { + mapCtx.Start = len(b) + mapCtx.First = len(b) + } + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + case encoder.OpMapKey: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + idx := mapCtx.Idx + idx++ + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + if idx < mapCtx.Len { + b = appendMapKeyIndent(ctx, code, b) + mapCtx.Idx = int(idx) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + b = appendObjectEnd(ctx, code, b) + encoder.ReleaseMapContext(mapCtx) + code = code.End.Next + } + } else { + mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)] + if idx < mapCtx.Len { + mapCtx.Idx = int(idx) + mapCtx.Start = len(b) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + code = code.End + } + } + case encoder.OpMapValue: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) + } else { + mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)] + mapCtx.Start = len(b) + } + value := mapitervalue(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(value)) + mapiternext(&mapCtx.Iter) + code = code.Next + case encoder.OpMapEnd: + // this operation only used by sorted map. + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + sort.Sort(mapCtx.Slice) + buf := mapCtx.Buf + for _, item := range mapCtx.Slice.Items { + buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value) + } + buf = appendMapEnd(ctx, code, buf) + b = b[:mapCtx.First] + b = append(b, buf...) + mapCtx.Buf = buf + encoder.ReleaseMapContext(mapCtx) + code = code.Next + case encoder.OpRecursivePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpRecursive: + ptr := load(ctxptr, code.Idx) + if ptr != 0 { + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if ptr == seen { + return nil, errUnsupportedValue(code, ptr) + } + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, ptr) + c := code.Jmp.Code + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += code.Jmp.CurLen * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + store(ctxptr, c.Idx, ptr) + store(ctxptr, c.End.Next.Idx, oldOffset) + store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpRecursiveEnd: + recursiveLevel-- + + // restore ctxptr + restoreIndent(ctx, code, ctxptr) + offset := load(ctxptr, code.Idx) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpStructPtrHead: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHead: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + } + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + u64 := ptrToUint64(p, code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + } + case encoder.OpStructPtrHeadNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructPtrHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyArray: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyArray: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptySlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptySlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + if maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p) + } + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructField: + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + p := load(ctxptr, code.Idx) + uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmpty: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringString: + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldMarshalJSON: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalJSONPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldMarshalText: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalTextPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldArrayPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArrayPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldSlice: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlice: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldSlicePtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldMap: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMap: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldMapPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldStruct: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyStruct: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructEnd: + b = appendStructEndSkipLast(ctx, code, b) + code = code.Next + case encoder.OpStructEndInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendStructEnd(ctx, code, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytesPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + code = code.Next + case encoder.OpStructEndOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpEnd: + goto END + } + } +END: + return b, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go new file mode 100644 index 00000000..925f61ed --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go @@ -0,0 +1,35 @@ +package vm_color + +import ( + "fmt" + + "github.com/goccy/go-json/internal/encoder" +) + +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + defer func() { + if err := recover(); err != nil { + w := ctx.Option.DebugOut + fmt.Fprintln(w, "=============[DEBUG]===============") + fmt.Fprintln(w, "* [TYPE]") + fmt.Fprintln(w, codeSet.Type) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [ALL OPCODE]") + fmt.Fprintln(w, code.Dump()) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [CONTEXT]") + fmt.Fprintf(w, "%+v\n", ctx) + fmt.Fprintln(w, "===================================") + panic(err) + } + }() + + return Run(ctx, b, codeSet) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go new file mode 100644 index 00000000..12ec56c5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go @@ -0,0 +1,9 @@ +package vm_color + +import ( + // HACK: compile order + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, + // so forcibly make dependencies and avoid compiling in concurrent. + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_color_indent" +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go new file mode 100644 index 00000000..33f29aee --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go @@ -0,0 +1,274 @@ +package vm_color + +import ( + "encoding/json" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +const uintptrSize = 4 << (^uintptr(0) >> 63) + +var ( + errUnsupportedValue = encoder.ErrUnsupportedValue + errUnsupportedFloat = encoder.ErrUnsupportedFloat + mapiterinit = encoder.MapIterInit + mapiterkey = encoder.MapIterKey + mapitervalue = encoder.MapIterValue + mapiternext = encoder.MapIterNext + maplen = encoder.MapLen +) + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + +func errUnimplementedOp(op encoder.OpType) error { + return fmt.Errorf("encoder: opcode %s has not been implemented", op) +} + +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) + return **(**uintptr)(unsafe.Pointer(&addr)) +} + +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) + **(**uintptr)(unsafe.Pointer(&addr)) = p +} + +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) + p := **(**uintptr)(unsafe.Pointer(&addr)) + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUint64(p uintptr, bitSize uint8) uint64 { + switch bitSize { + case 8: + return (uint64)(**(**uint8)(unsafe.Pointer(&p))) + case 16: + return (uint64)(**(**uint16)(unsafe.Pointer(&p))) + case 32: + return (uint64)(**(**uint32)(unsafe.Pointer(&p))) + case 64: + return **(**uint64)(unsafe.Pointer(&p)) + } + return 0 +} +func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) } +func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) } +func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) } +func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) } +func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) } +func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) } +func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) } +func ptrToPtr(p uintptr) uintptr { + return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p))) +} +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUnsafePtr(p uintptr) unsafe.Pointer { + return *(*unsafe.Pointer)(unsafe.Pointer(&p)) +} +func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { + return *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) +} + +func appendInt(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + b = encoder.AppendInt(ctx, b, p, code) + return append(b, format.Footer...) +} + +func appendUint(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Uint + b = append(b, format.Header...) + b = encoder.AppendUint(ctx, b, p, code) + return append(b, format.Footer...) +} + +func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat32(ctx, b, v) + return append(b, format.Footer...) +} + +func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat64(ctx, b, v) + return append(b, format.Footer...) +} + +func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + b = encoder.AppendString(ctx, b, v) + return append(b, format.Footer...) +} + +func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte { + format := ctx.Option.ColorScheme.Binary + b = append(b, format.Header...) + b = encoder.AppendByteSlice(ctx, b, src) + return append(b, format.Footer...) +} + +func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + bb, err := encoder.AppendNumber(ctx, b, n) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil +} + +func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte { + format := ctx.Option.ColorScheme.Bool + b = append(b, format.Header...) + if v { + b = append(b, "true"...) + } else { + b = append(b, "false"...) + } + return append(b, format.Footer...) +} + +func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(b, format.Footer...) +} + +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ',') +} + +func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(append(b, format.Footer...), ',') +} + +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { + last := len(b) - 1 + b[last] = ':' + return b +} + +func appendMapKeyValue(_ *encoder.RuntimeContext, _ *encoder.Opcode, b, key, value []byte) []byte { + b = append(b, key[:len(key)-1]...) + b = append(b, ':') + return append(b, value...) +} + +func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + b[last] = '}' + b = append(b, ',') + return b +} + +func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalJSON(ctx, code, b, v) +} + +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + bb, err := encoder.AppendMarshalText(ctx, code, b, v) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil +} + +func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + return append(b, '[') +} + +func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + b[last] = ']' + return append(b, ',') +} + +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '[', ']', ',') +} + +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '}', ',') +} + +func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + b[last] = '}' + return append(b, ',') +} + +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{') +} + +func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + format := ctx.Option.ColorScheme.ObjectKey + b = append(b, format.Header...) + b = append(b, code.Key[:len(code.Key)-1]...) + b = append(b, format.Footer...) + + return append(b, ':') +} + +func appendStructEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { + return append(b, '}', ',') +} + +func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + if b[last] == ',' { + b[last] = '}' + return appendComma(ctx, b) + } + return appendStructEnd(ctx, code, b) +} + +func restoreIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, _ uintptr) {} +func storeIndent(_ uintptr, _ *encoder.Opcode, _ uintptr) {} +func appendMapKeyIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b } +func appendArrayElemIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go new file mode 100644 index 00000000..a63e83e5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go @@ -0,0 +1,4859 @@ +// Code generated by internal/cmd/generator. DO NOT EDIT! +package vm_color + +import ( + "math" + "reflect" + "sort" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + recursiveLevel := 0 + ptrOffset := uintptr(0) + ctxptr := ctx.Ptr() + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + for { + switch code.Op { + default: + return nil, errUnimplementedOp(code.Op) + case encoder.OpPtr: + p := load(ctxptr, code.Idx) + code = code.Next + store(ctxptr, code.Idx, ptrToPtr(p)) + case encoder.OpIntPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInt: + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpUint: + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpIntString: + b = append(b, '"') + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintString: + b = append(b, '"') + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat32Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat32: + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat64Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat64: + v := ptrToFloat64(load(ctxptr, code.Idx)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStringPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpString: + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBoolPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBool: + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBytesPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBytes: + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpNumberPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpNumber: + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpInterfacePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInterface: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, p) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + if iface.itab != nil { + typ = iface.itab.typ + } + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ) + if !isDirectedNil { + b = appendNullComma(ctx, b) + code = code.Next + break + } + } + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ))) + if err != nil { + return nil, err + } + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + ctx.BaseIndent += code.Indent + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + b = append(b, `""`...) + b = appendComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpSlicePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpSlice: + p := load(ctxptr, code.Idx) + slice := ptrToSlice(p) + if p == 0 || slice.Data == nil { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.ElemIdx, 0) + store(ctxptr, code.Length, uintptr(slice.Len)) + store(ctxptr, code.Idx, uintptr(slice.Data)) + if slice.Len > 0 { + b = appendArrayHead(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, uintptr(slice.Data)) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpSliceElem: + idx := load(ctxptr, code.ElemIdx) + length := load(ctxptr, code.Length) + idx++ + if idx < length { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, data+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpArrayPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpArray: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + if code.Length > 0 { + b = appendArrayHead(ctx, code, b) + store(ctxptr, code.ElemIdx, 0) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpArrayElem: + idx := load(ctxptr, code.ElemIdx) + idx++ + if idx < uintptr(code.Length) { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, p+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpMapPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpMap: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + uptr := ptrToUnsafePtr(p) + mlen := maplen(uptr) + if mlen <= 0 { + b = appendEmptyObject(ctx, b) + code = code.End.Next + break + } + b = appendStructHead(ctx, b) + unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 + mapCtx := encoder.NewMapContext(mlen, unorderedMap) + mapiterinit(code.Type, uptr, &mapCtx.Iter) + store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx))) + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) + if unorderedMap { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { + mapCtx.Start = len(b) + mapCtx.First = len(b) + } + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + case encoder.OpMapKey: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + idx := mapCtx.Idx + idx++ + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + if idx < mapCtx.Len { + b = appendMapKeyIndent(ctx, code, b) + mapCtx.Idx = int(idx) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + b = appendObjectEnd(ctx, code, b) + encoder.ReleaseMapContext(mapCtx) + code = code.End.Next + } + } else { + mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)] + if idx < mapCtx.Len { + mapCtx.Idx = int(idx) + mapCtx.Start = len(b) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + code = code.End + } + } + case encoder.OpMapValue: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) + } else { + mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)] + mapCtx.Start = len(b) + } + value := mapitervalue(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(value)) + mapiternext(&mapCtx.Iter) + code = code.Next + case encoder.OpMapEnd: + // this operation only used by sorted map. + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + sort.Sort(mapCtx.Slice) + buf := mapCtx.Buf + for _, item := range mapCtx.Slice.Items { + buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value) + } + buf = appendMapEnd(ctx, code, buf) + b = b[:mapCtx.First] + b = append(b, buf...) + mapCtx.Buf = buf + encoder.ReleaseMapContext(mapCtx) + code = code.Next + case encoder.OpRecursivePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpRecursive: + ptr := load(ctxptr, code.Idx) + if ptr != 0 { + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if ptr == seen { + return nil, errUnsupportedValue(code, ptr) + } + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, ptr) + c := code.Jmp.Code + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += code.Jmp.CurLen * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + store(ctxptr, c.Idx, ptr) + store(ctxptr, c.End.Next.Idx, oldOffset) + store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpRecursiveEnd: + recursiveLevel-- + + // restore ctxptr + restoreIndent(ctx, code, ctxptr) + offset := load(ctxptr, code.Idx) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpStructPtrHead: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHead: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + } + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + u64 := ptrToUint64(p, code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + } + case encoder.OpStructPtrHeadNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructPtrHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyArray: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyArray: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptySlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptySlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + if maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p) + } + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructField: + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + p := load(ctxptr, code.Idx) + uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmpty: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringString: + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldMarshalJSON: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalJSONPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldMarshalText: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalTextPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldArrayPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArrayPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldSlice: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlice: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldSlicePtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldMap: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMap: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldMapPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldStruct: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyStruct: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructEnd: + b = appendStructEndSkipLast(ctx, code, b) + code = code.Next + case encoder.OpStructEndInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendStructEnd(ctx, code, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytesPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + code = code.Next + case encoder.OpStructEndOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpEnd: + goto END + } + } +END: + return b, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go new file mode 100644 index 00000000..dd4cd489 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go @@ -0,0 +1,35 @@ +package vm_color_indent + +import ( + "fmt" + + "github.com/goccy/go-json/internal/encoder" +) + +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + defer func() { + if err := recover(); err != nil { + w := ctx.Option.DebugOut + fmt.Fprintln(w, "=============[DEBUG]===============") + fmt.Fprintln(w, "* [TYPE]") + fmt.Fprintln(w, codeSet.Type) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [ALL OPCODE]") + fmt.Fprintln(w, code.Dump()) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [CONTEXT]") + fmt.Fprintf(w, "%+v\n", ctx) + fmt.Fprintln(w, "===================================") + panic(err) + } + }() + + return Run(ctx, b, codeSet) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go new file mode 100644 index 00000000..2395abec --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go @@ -0,0 +1,297 @@ +package vm_color_indent + +import ( + "encoding/json" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +const uintptrSize = 4 << (^uintptr(0) >> 63) + +var ( + appendIndent = encoder.AppendIndent + appendStructEnd = encoder.AppendStructEndIndent + errUnsupportedValue = encoder.ErrUnsupportedValue + errUnsupportedFloat = encoder.ErrUnsupportedFloat + mapiterinit = encoder.MapIterInit + mapiterkey = encoder.MapIterKey + mapitervalue = encoder.MapIterValue + mapiternext = encoder.MapIterNext + maplen = encoder.MapLen +) + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + +func errUnimplementedOp(op encoder.OpType) error { + return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op) +} + +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) + return **(**uintptr)(unsafe.Pointer(&addr)) +} + +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) + **(**uintptr)(unsafe.Pointer(&addr)) = p +} + +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) + p := **(**uintptr)(unsafe.Pointer(&addr)) + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUint64(p uintptr, bitSize uint8) uint64 { + switch bitSize { + case 8: + return (uint64)(**(**uint8)(unsafe.Pointer(&p))) + case 16: + return (uint64)(**(**uint16)(unsafe.Pointer(&p))) + case 32: + return (uint64)(**(**uint32)(unsafe.Pointer(&p))) + case 64: + return **(**uint64)(unsafe.Pointer(&p)) + } + return 0 +} + +func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) } +func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) } +func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) } +func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) } +func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) } +func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) } +func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) } +func ptrToPtr(p uintptr) uintptr { + return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p))) +} +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUnsafePtr(p uintptr) unsafe.Pointer { + return *(*unsafe.Pointer)(unsafe.Pointer(&p)) +} +func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { + return *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) +} + +func appendInt(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + b = encoder.AppendInt(ctx, b, p, code) + return append(b, format.Footer...) +} + +func appendUint(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Uint + b = append(b, format.Header...) + b = encoder.AppendUint(ctx, b, p, code) + return append(b, format.Footer...) +} + +func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat32(ctx, b, v) + return append(b, format.Footer...) +} + +func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat64(ctx, b, v) + return append(b, format.Footer...) +} + +func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + b = encoder.AppendString(ctx, b, v) + return append(b, format.Footer...) +} + +func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte { + format := ctx.Option.ColorScheme.Binary + b = append(b, format.Header...) + b = encoder.AppendByteSlice(ctx, b, src) + return append(b, format.Footer...) +} + +func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + bb, err := encoder.AppendNumber(ctx, b, n) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil +} + +func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte { + format := ctx.Option.ColorScheme.Bool + b = append(b, format.Header...) + if v { + b = append(b, "true"...) + } else { + b = append(b, "false"...) + } + return append(b, format.Footer...) +} + +func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(b, format.Footer...) +} + +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ',', '\n') +} + +func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(append(b, format.Footer...), ',', '\n') +} + +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b[:len(b)-2], ':', ' ') +} + +func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { + b = appendIndent(ctx, b, code.Indent+1) + b = append(b, key...) + b[len(b)-2] = ':' + b[len(b)-1] = ' ' + return append(b, value...) +} + +func appendMapEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = b[:len(b)-2] + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent) + return append(b, '}', ',', '\n') +} + +func appendArrayHead(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = append(b, '[', '\n') + return appendIndent(ctx, b, code.Indent+1) +} + +func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = b[:len(b)-2] + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent) + return append(b, ']', ',', '\n') +} + +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '[', ']', ',', '\n') +} + +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '}', ',', '\n') +} + +func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + // replace comma to newline + b[last-1] = '\n' + b = appendIndent(ctx, b[:last], code.Indent) + return append(b, '}', ',', '\n') +} + +func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalJSONIndent(ctx, code, b, v) +} + +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + bb, err := encoder.AppendMarshalTextIndent(ctx, code, b, v) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil +} + +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '\n') +} + +func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = appendIndent(ctx, b, code.Indent) + + format := ctx.Option.ColorScheme.ObjectKey + b = append(b, format.Header...) + b = append(b, code.Key[:len(code.Key)-1]...) + b = append(b, format.Footer...) + + return append(b, ':', ' ') +} + +func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + if b[last-1] == '{' { + b[last] = '}' + } else { + if b[last] == '\n' { + // to remove ',' and '\n' characters + b = b[:len(b)-2] + } + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent-1) + b = append(b, '}') + } + return appendComma(ctx, b) +} + +func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) { + ctx.BaseIndent = uint32(load(ctxptr, code.Length)) +} + +func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) { + store(ctxptr, code.Length, indent) +} + +func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + return appendIndent(ctx, b, code.Indent+1) +} + +func appendMapKeyIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + return appendIndent(ctx, b, code.Indent) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go new file mode 100644 index 00000000..3b4e22e5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go @@ -0,0 +1,4859 @@ +// Code generated by internal/cmd/generator. DO NOT EDIT! +package vm_color_indent + +import ( + "math" + "reflect" + "sort" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + recursiveLevel := 0 + ptrOffset := uintptr(0) + ctxptr := ctx.Ptr() + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + for { + switch code.Op { + default: + return nil, errUnimplementedOp(code.Op) + case encoder.OpPtr: + p := load(ctxptr, code.Idx) + code = code.Next + store(ctxptr, code.Idx, ptrToPtr(p)) + case encoder.OpIntPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInt: + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpUint: + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpIntString: + b = append(b, '"') + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintString: + b = append(b, '"') + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat32Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat32: + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat64Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat64: + v := ptrToFloat64(load(ctxptr, code.Idx)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStringPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpString: + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBoolPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBool: + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBytesPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBytes: + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpNumberPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpNumber: + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpInterfacePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInterface: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, p) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + if iface.itab != nil { + typ = iface.itab.typ + } + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ) + if !isDirectedNil { + b = appendNullComma(ctx, b) + code = code.Next + break + } + } + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ))) + if err != nil { + return nil, err + } + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + ctx.BaseIndent += code.Indent + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + b = append(b, `""`...) + b = appendComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpSlicePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpSlice: + p := load(ctxptr, code.Idx) + slice := ptrToSlice(p) + if p == 0 || slice.Data == nil { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.ElemIdx, 0) + store(ctxptr, code.Length, uintptr(slice.Len)) + store(ctxptr, code.Idx, uintptr(slice.Data)) + if slice.Len > 0 { + b = appendArrayHead(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, uintptr(slice.Data)) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpSliceElem: + idx := load(ctxptr, code.ElemIdx) + length := load(ctxptr, code.Length) + idx++ + if idx < length { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, data+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpArrayPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpArray: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + if code.Length > 0 { + b = appendArrayHead(ctx, code, b) + store(ctxptr, code.ElemIdx, 0) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpArrayElem: + idx := load(ctxptr, code.ElemIdx) + idx++ + if idx < uintptr(code.Length) { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, p+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpMapPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpMap: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + uptr := ptrToUnsafePtr(p) + mlen := maplen(uptr) + if mlen <= 0 { + b = appendEmptyObject(ctx, b) + code = code.End.Next + break + } + b = appendStructHead(ctx, b) + unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 + mapCtx := encoder.NewMapContext(mlen, unorderedMap) + mapiterinit(code.Type, uptr, &mapCtx.Iter) + store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx))) + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) + if unorderedMap { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { + mapCtx.Start = len(b) + mapCtx.First = len(b) + } + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + case encoder.OpMapKey: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + idx := mapCtx.Idx + idx++ + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + if idx < mapCtx.Len { + b = appendMapKeyIndent(ctx, code, b) + mapCtx.Idx = int(idx) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + b = appendObjectEnd(ctx, code, b) + encoder.ReleaseMapContext(mapCtx) + code = code.End.Next + } + } else { + mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)] + if idx < mapCtx.Len { + mapCtx.Idx = int(idx) + mapCtx.Start = len(b) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + code = code.End + } + } + case encoder.OpMapValue: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) + } else { + mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)] + mapCtx.Start = len(b) + } + value := mapitervalue(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(value)) + mapiternext(&mapCtx.Iter) + code = code.Next + case encoder.OpMapEnd: + // this operation only used by sorted map. + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + sort.Sort(mapCtx.Slice) + buf := mapCtx.Buf + for _, item := range mapCtx.Slice.Items { + buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value) + } + buf = appendMapEnd(ctx, code, buf) + b = b[:mapCtx.First] + b = append(b, buf...) + mapCtx.Buf = buf + encoder.ReleaseMapContext(mapCtx) + code = code.Next + case encoder.OpRecursivePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpRecursive: + ptr := load(ctxptr, code.Idx) + if ptr != 0 { + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if ptr == seen { + return nil, errUnsupportedValue(code, ptr) + } + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, ptr) + c := code.Jmp.Code + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += code.Jmp.CurLen * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + store(ctxptr, c.Idx, ptr) + store(ctxptr, c.End.Next.Idx, oldOffset) + store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpRecursiveEnd: + recursiveLevel-- + + // restore ctxptr + restoreIndent(ctx, code, ctxptr) + offset := load(ctxptr, code.Idx) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpStructPtrHead: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHead: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + } + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + u64 := ptrToUint64(p, code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + } + case encoder.OpStructPtrHeadNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructPtrHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyArray: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyArray: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptySlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptySlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + if maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p) + } + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructField: + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + p := load(ctxptr, code.Idx) + uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmpty: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringString: + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldMarshalJSON: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalJSONPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldMarshalText: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalTextPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldArrayPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArrayPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldSlice: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlice: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldSlicePtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldMap: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMap: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldMapPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldStruct: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyStruct: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructEnd: + b = appendStructEndSkipLast(ctx, code, b) + code = code.Next + case encoder.OpStructEndInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendStructEnd(ctx, code, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytesPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + code = code.Next + case encoder.OpStructEndOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpEnd: + goto END + } + } +END: + return b, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go new file mode 100644 index 00000000..99395388 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go @@ -0,0 +1,35 @@ +package vm_indent + +import ( + "fmt" + + "github.com/goccy/go-json/internal/encoder" +) + +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + defer func() { + if err := recover(); err != nil { + w := ctx.Option.DebugOut + fmt.Fprintln(w, "=============[DEBUG]===============") + fmt.Fprintln(w, "* [TYPE]") + fmt.Fprintln(w, codeSet.Type) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [ALL OPCODE]") + fmt.Fprintln(w, code.Dump()) + fmt.Fprintf(w, "\n") + fmt.Fprintln(w, "* [CONTEXT]") + fmt.Fprintf(w, "%+v\n", ctx) + fmt.Fprintln(w, "===================================") + panic(err) + } + }() + + return Run(ctx, b, codeSet) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go new file mode 100644 index 00000000..9e245bfe --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go @@ -0,0 +1,9 @@ +package vm_indent + +import ( + // HACK: compile order + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, + // so forcibly make dependencies and avoid compiling in concurrent. + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_color" +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go new file mode 100644 index 00000000..6cb745e3 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go @@ -0,0 +1,230 @@ +package vm_indent + +import ( + "encoding/json" + "fmt" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +const uintptrSize = 4 << (^uintptr(0) >> 63) + +var ( + appendInt = encoder.AppendInt + appendUint = encoder.AppendUint + appendFloat32 = encoder.AppendFloat32 + appendFloat64 = encoder.AppendFloat64 + appendString = encoder.AppendString + appendByteSlice = encoder.AppendByteSlice + appendNumber = encoder.AppendNumber + appendStructEnd = encoder.AppendStructEndIndent + appendIndent = encoder.AppendIndent + errUnsupportedValue = encoder.ErrUnsupportedValue + errUnsupportedFloat = encoder.ErrUnsupportedFloat + mapiterinit = encoder.MapIterInit + mapiterkey = encoder.MapIterKey + mapitervalue = encoder.MapIterValue + mapiternext = encoder.MapIterNext + maplen = encoder.MapLen +) + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + +func errUnimplementedOp(op encoder.OpType) error { + return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op) +} + +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) + return **(**uintptr)(unsafe.Pointer(&addr)) +} + +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) + **(**uintptr)(unsafe.Pointer(&addr)) = p +} + +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) + p := **(**uintptr)(unsafe.Pointer(&addr)) + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUint64(p uintptr, bitSize uint8) uint64 { + switch bitSize { + case 8: + return (uint64)(**(**uint8)(unsafe.Pointer(&p))) + case 16: + return (uint64)(**(**uint16)(unsafe.Pointer(&p))) + case 32: + return (uint64)(**(**uint32)(unsafe.Pointer(&p))) + case 64: + return **(**uint64)(unsafe.Pointer(&p)) + } + return 0 +} +func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) } +func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) } +func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) } +func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) } +func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) } +func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) } +func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) } +func ptrToPtr(p uintptr) uintptr { + return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p))) +} +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { + if p == 0 { + return 0 + } + p = ptrToPtr(p) + } + return p +} + +func ptrToUnsafePtr(p uintptr) unsafe.Pointer { + return *(*unsafe.Pointer)(unsafe.Pointer(&p)) +} +func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { + return *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: code.Type, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) +} + +func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte { + if v { + return append(b, "true"...) + } + return append(b, "false"...) +} + +func appendNull(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, "null"...) +} + +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ',', '\n') +} + +func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, "null,\n"...) +} + +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b[:len(b)-2], ':', ' ') +} + +func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { + b = appendIndent(ctx, b, code.Indent+1) + b = append(b, key...) + b[len(b)-2] = ':' + b[len(b)-1] = ' ' + return append(b, value...) +} + +func appendMapEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = b[:len(b)-2] + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent) + return append(b, '}', ',', '\n') +} + +func appendArrayHead(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = append(b, '[', '\n') + return appendIndent(ctx, b, code.Indent+1) +} + +func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = b[:len(b)-2] + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent) + return append(b, ']', ',', '\n') +} + +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '[', ']', ',', '\n') +} + +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '}', ',', '\n') +} + +func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + // replace comma to newline + b[last-1] = '\n' + b = appendIndent(ctx, b[:last], code.Indent) + return append(b, '}', ',', '\n') +} + +func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalJSONIndent(ctx, code, b, v) +} + +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalTextIndent(ctx, code, b, v) +} + +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, '{', '\n') +} + +func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + b = appendIndent(ctx, b, code.Indent) + b = append(b, code.Key...) + return append(b, ' ') +} + +func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + last := len(b) - 1 + if b[last-1] == '{' { + b[last] = '}' + } else { + if b[last] == '\n' { + // to remove ',' and '\n' characters + b = b[:len(b)-2] + } + b = append(b, '\n') + b = appendIndent(ctx, b, code.Indent-1) + b = append(b, '}') + } + return appendComma(ctx, b) +} + +func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) { + ctx.BaseIndent = uint32(load(ctxptr, code.Length)) +} + +func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) { + store(ctxptr, code.Length, indent) +} + +func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + return appendIndent(ctx, b, code.Indent+1) +} + +func appendMapKeyIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + return appendIndent(ctx, b, code.Indent) +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go new file mode 100644 index 00000000..836c5c8a --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go @@ -0,0 +1,4859 @@ +// Code generated by internal/cmd/generator. DO NOT EDIT! +package vm_indent + +import ( + "math" + "reflect" + "sort" + "unsafe" + + "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" +) + +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + recursiveLevel := 0 + ptrOffset := uintptr(0) + ctxptr := ctx.Ptr() + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + + for { + switch code.Op { + default: + return nil, errUnimplementedOp(code.Op) + case encoder.OpPtr: + p := load(ctxptr, code.Idx) + code = code.Next + store(ctxptr, code.Idx, ptrToPtr(p)) + case encoder.OpIntPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInt: + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpUint: + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpIntString: + b = append(b, '"') + b = appendInt(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpUintString: + b = append(b, '"') + b = appendUint(ctx, b, load(ctxptr, code.Idx), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat32Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat32: + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpFloat64Ptr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpFloat64: + v := ptrToFloat64(load(ctxptr, code.Idx)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStringPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpString: + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBoolPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBool: + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpBytesPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpBytes: + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpNumberPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpNumber: + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpInterfacePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpInterface: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, p) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + if iface.itab != nil { + typ = iface.itab.typ + } + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ) + if !isDirectedNil { + b = appendNullComma(ctx, b) + code = code.Next + break + } + } + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ))) + if err != nil { + return nil, err + } + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + ctx.BaseIndent += code.Indent + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToPtr(p)) + fallthrough + case encoder.OpMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + b = append(b, `""`...) + b = appendComma(ctx, b) + code = code.Next + break + } + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p) + } + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpSlicePtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpSlice: + p := load(ctxptr, code.Idx) + slice := ptrToSlice(p) + if p == 0 || slice.Data == nil { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.ElemIdx, 0) + store(ctxptr, code.Length, uintptr(slice.Len)) + store(ctxptr, code.Idx, uintptr(slice.Data)) + if slice.Len > 0 { + b = appendArrayHead(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, uintptr(slice.Data)) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpSliceElem: + idx := load(ctxptr, code.ElemIdx) + length := load(ctxptr, code.Length) + idx++ + if idx < length { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, data+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpArrayPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpArray: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + if code.Length > 0 { + b = appendArrayHead(ctx, code, b) + store(ctxptr, code.ElemIdx, 0) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + b = appendEmptyArray(ctx, b) + code = code.End.Next + } + case encoder.OpArrayElem: + idx := load(ctxptr, code.ElemIdx) + idx++ + if idx < uintptr(code.Length) { + b = appendArrayElemIndent(ctx, code, b) + store(ctxptr, code.ElemIdx, idx) + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) + code = code.Next + store(ctxptr, code.Idx, p+idx*size) + } else { + b = appendArrayEnd(ctx, code, b) + code = code.End.Next + } + case encoder.OpMapPtr: + p := loadNPtr(ctxptr, code.Idx, code.PtrNum) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + store(ctxptr, code.Idx, p) + fallthrough + case encoder.OpMap: + p := load(ctxptr, code.Idx) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.End.Next + break + } + uptr := ptrToUnsafePtr(p) + mlen := maplen(uptr) + if mlen <= 0 { + b = appendEmptyObject(ctx, b) + code = code.End.Next + break + } + b = appendStructHead(ctx, b) + unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 + mapCtx := encoder.NewMapContext(mlen, unorderedMap) + mapiterinit(code.Type, uptr, &mapCtx.Iter) + store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx))) + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) + if unorderedMap { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { + mapCtx.Start = len(b) + mapCtx.First = len(b) + } + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + case encoder.OpMapKey: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + idx := mapCtx.Idx + idx++ + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + if idx < mapCtx.Len { + b = appendMapKeyIndent(ctx, code, b) + mapCtx.Idx = int(idx) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + b = appendObjectEnd(ctx, code, b) + encoder.ReleaseMapContext(mapCtx) + code = code.End.Next + } + } else { + mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)] + if idx < mapCtx.Len { + mapCtx.Idx = int(idx) + mapCtx.Start = len(b) + key := mapiterkey(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(key)) + code = code.Next + } else { + code = code.End + } + } + case encoder.OpMapValue: + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) + } else { + mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)] + mapCtx.Start = len(b) + } + value := mapitervalue(&mapCtx.Iter) + store(ctxptr, code.Next.Idx, uintptr(value)) + mapiternext(&mapCtx.Iter) + code = code.Next + case encoder.OpMapEnd: + // this operation only used by sorted map. + mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx))) + sort.Sort(mapCtx.Slice) + buf := mapCtx.Buf + for _, item := range mapCtx.Slice.Items { + buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value) + } + buf = appendMapEnd(ctx, code, buf) + b = b[:mapCtx.First] + b = append(b, buf...) + mapCtx.Buf = buf + encoder.ReleaseMapContext(mapCtx) + code = code.Next + case encoder.OpRecursivePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + code = code.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpRecursive: + ptr := load(ctxptr, code.Idx) + if ptr != 0 { + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if ptr == seen { + return nil, errUnsupportedValue(code, ptr) + } + } + } + } + ctx.SeenPtr = append(ctx.SeenPtr, ptr) + c := code.Jmp.Code + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += code.Jmp.CurLen * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + store(ctxptr, c.Idx, ptr) + store(ctxptr, c.End.Next.Idx, oldOffset) + store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpRecursiveEnd: + recursiveLevel-- + + // restore ctxptr + restoreIndent(ctx, code, ctxptr) + offset := load(ctxptr, code.Idx) + ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] + + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset + case encoder.OpStructPtrHead: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHead: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + } + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmpty: + p := load(ctxptr, code.Idx) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyInt: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyInt: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyIntString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + u64 := ptrToUint64(p, code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUint: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUint: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyUintString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat32(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64String: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToFloat64(p + uintptr(code.Offset)) + if v == 0 { + code = code.NextField + } else { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyStringString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToString(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBool: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBool: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + } else { + code = code.NextField + } + case encoder.OpStructPtrHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytes: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyBytes: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumber: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumber: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + } + case encoder.OpStructPtrHeadNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberString: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + v := ptrToNumber(p + uintptr(code.Offset)) + if v == "" { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructPtrHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyArray: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyArray: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptySlice: + if (code.Flags & encoder.IndirectFlags) != 0 { + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptySlice: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructPtrHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMap: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) + } + if maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + break + } + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 { + code = code.NextField + } else { + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructPtrHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p) + } + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + } + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p) + } + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructPtrHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + b = appendStructKey(ctx, code, b) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) + fallthrough + case encoder.OpStructHeadOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNullComma(ctx, b) + } + code = code.End.Next + break + } + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + } + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) + } + if p == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + b = appendComma(ctx, b) + code = code.Next + } + case encoder.OpStructField: + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } + p := load(ctxptr, code.Idx) + uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmpty: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNullComma(ctx, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringString: + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + b = appendStructKey(ctx, code, b) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendComma(ctx, b) + } + code = code.Next + case encoder.OpStructFieldMarshalJSON: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSON: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + iface := ptrToInterface(code, p) + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, iface) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalJSONPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldMarshalText: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalText: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + p = ptrToPtr(p) + } + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + code = code.NextField + break + } + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + code = code.Next + case encoder.OpStructFieldMarshalTextPtr: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendComma(ctx, b) + code = code.Next + case encoder.OpStructFieldOmitEmptyMarshalTextPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) + if err != nil { + return nil, err + } + b = appendComma(ctx, bb) + } + code = code.Next + case encoder.OpStructFieldArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArray: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldArrayPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyArrayPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldSlice: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlice: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + slice := ptrToSlice(p) + if slice.Len == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldSlicePtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptySlicePtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldMap: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMap: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructFieldMapPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyMapPtr: + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) + if p != 0 { + p = ptrToNPtr(p, code.PtrNum) + } + if p != 0 { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } else { + code = code.NextField + } + case encoder.OpStructFieldStruct: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + code = code.Next + store(ctxptr, code.Idx, p) + case encoder.OpStructFieldOmitEmptyStruct: + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { + code = code.NextField + } else { + b = appendStructKey(ctx, code, b) + code = code.Next + store(ctxptr, code.Idx, p) + } + case encoder.OpStructEnd: + b = appendStructEndSkipLast(ctx, code, b) + code = code.Next + case encoder.OpStructEndInt: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyInt: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendInt(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendInt(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndIntPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyIntPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendInt(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUint: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUint: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintString: + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize) + v := u64 & ((1 << code.NumBitSize) - 1) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p+uintptr(code.Offset), code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendUint(ctx, b, p, code) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendUint(ctx, b, p, code) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndUintPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyUintPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendUint(ctx, b, p, code) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32String: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32String: + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) + if v != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendFloat32(ctx, b, ptrToFloat32(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat32PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat32PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64String: + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) + if v != 0 { + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64Ptr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + b = appendStructEnd(ctx, code, b) + code = code.Next + break + } + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64Ptr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndFloat64PtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = appendFloat64(ctx, b, v) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyFloat64PtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + v := ptrToFloat64(p) + if math.IsInf(v, 0) || math.IsNaN(v) { + return nil, errUnsupportedFloat(v) + } + b = append(b, '"') + b = appendFloat64(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringString: + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, ptrToString(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, ptrToString(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndStringPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyStringPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBool: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBool: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolString: + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) + if v { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, v) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendBool(ctx, b, ptrToBool(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBoolPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBoolPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + b = appendBool(ctx, b, ptrToBool(p)) + b = append(b, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytes: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytes: + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) + if len(v) > 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, v) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndBytesPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = appendByteSlice(ctx, b, ptrToBytes(p)) + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyBytesPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumber: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + code = code.Next + case encoder.OpStructEndOmitEmptyNumber: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberString: + p := load(ctxptr, code.Idx) + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberString: + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) + if v != "" { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, v) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtr: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = bb + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtr: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = appendStructEnd(ctx, code, bb) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpStructEndNumberPtrString: + b = appendStructKey(ctx, code, b) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p == 0 { + b = appendNull(ctx, b) + } else { + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + } + b = appendStructEnd(ctx, code, b) + code = code.Next + case encoder.OpStructEndOmitEmptyNumberPtrString: + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) + if p != 0 { + b = appendStructKey(ctx, code, b) + b = append(b, '"') + bb, err := appendNumber(ctx, b, ptrToNumber(p)) + if err != nil { + return nil, err + } + b = append(bb, '"') + b = appendStructEnd(ctx, code, b) + } else { + b = appendStructEndSkipLast(ctx, code, b) + } + code = code.Next + case encoder.OpEnd: + goto END + } + } +END: + return b, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/errors/error.go b/vendor/github.com/goccy/go-json/internal/errors/error.go new file mode 100644 index 00000000..9207d0ff --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/errors/error.go @@ -0,0 +1,183 @@ +package errors + +import ( + "fmt" + "reflect" + "strconv" +) + +type InvalidUTF8Error struct { + S string // the whole string value that caused the error +} + +func (e *InvalidUTF8Error) Error() string { + return fmt.Sprintf("json: invalid UTF-8 in string: %s", strconv.Quote(e.S)) +} + +type InvalidUnmarshalError struct { + Type reflect.Type +} + +func (e *InvalidUnmarshalError) Error() string { + if e.Type == nil { + return "json: Unmarshal(nil)" + } + + if e.Type.Kind() != reflect.Ptr { + return fmt.Sprintf("json: Unmarshal(non-pointer %s)", e.Type) + } + return fmt.Sprintf("json: Unmarshal(nil %s)", e.Type) +} + +// A MarshalerError represents an error from calling a MarshalJSON or MarshalText method. +type MarshalerError struct { + Type reflect.Type + Err error + sourceFunc string +} + +func (e *MarshalerError) Error() string { + srcFunc := e.sourceFunc + if srcFunc == "" { + srcFunc = "MarshalJSON" + } + return fmt.Sprintf("json: error calling %s for type %s: %s", srcFunc, e.Type, e.Err.Error()) +} + +// Unwrap returns the underlying error. +func (e *MarshalerError) Unwrap() error { return e.Err } + +// A SyntaxError is a description of a JSON syntax error. +type SyntaxError struct { + msg string // description of error + Offset int64 // error occurred after reading Offset bytes +} + +func (e *SyntaxError) Error() string { return e.msg } + +// An UnmarshalFieldError describes a JSON object key that +// led to an unexported (and therefore unwritable) struct field. +// +// Deprecated: No longer used; kept for compatibility. +type UnmarshalFieldError struct { + Key string + Type reflect.Type + Field reflect.StructField +} + +func (e *UnmarshalFieldError) Error() string { + return fmt.Sprintf("json: cannot unmarshal object key %s into unexported field %s of type %s", + strconv.Quote(e.Key), e.Field.Name, e.Type.String(), + ) +} + +// An UnmarshalTypeError describes a JSON value that was +// not appropriate for a value of a specific Go type. +type UnmarshalTypeError struct { + Value string // description of JSON value - "bool", "array", "number -5" + Type reflect.Type // type of Go value it could not be assigned to + Offset int64 // error occurred after reading Offset bytes + Struct string // name of the struct type containing the field + Field string // the full path from root node to the field +} + +func (e *UnmarshalTypeError) Error() string { + if e.Struct != "" || e.Field != "" { + return fmt.Sprintf("json: cannot unmarshal %s into Go struct field %s.%s of type %s", + e.Value, e.Struct, e.Field, e.Type, + ) + } + return fmt.Sprintf("json: cannot unmarshal %s into Go value of type %s", e.Value, e.Type) +} + +// An UnsupportedTypeError is returned by Marshal when attempting +// to encode an unsupported value type. +type UnsupportedTypeError struct { + Type reflect.Type +} + +func (e *UnsupportedTypeError) Error() string { + return fmt.Sprintf("json: unsupported type: %s", e.Type) +} + +type UnsupportedValueError struct { + Value reflect.Value + Str string +} + +func (e *UnsupportedValueError) Error() string { + return fmt.Sprintf("json: unsupported value: %s", e.Str) +} + +func ErrSyntax(msg string, offset int64) *SyntaxError { + return &SyntaxError{msg: msg, Offset: offset} +} + +func ErrMarshaler(typ reflect.Type, err error, msg string) *MarshalerError { + return &MarshalerError{ + Type: typ, + Err: err, + sourceFunc: msg, + } +} + +func ErrExceededMaxDepth(c byte, cursor int64) *SyntaxError { + return &SyntaxError{ + msg: fmt.Sprintf(`invalid character "%c" exceeded max depth`, c), + Offset: cursor, + } +} + +func ErrNotAtBeginningOfValue(cursor int64) *SyntaxError { + return &SyntaxError{msg: "not at beginning of value", Offset: cursor} +} + +func ErrUnexpectedEndOfJSON(msg string, cursor int64) *SyntaxError { + return &SyntaxError{ + msg: fmt.Sprintf("json: %s unexpected end of JSON input", msg), + Offset: cursor, + } +} + +func ErrExpected(msg string, cursor int64) *SyntaxError { + return &SyntaxError{msg: fmt.Sprintf("expected %s", msg), Offset: cursor} +} + +func ErrInvalidCharacter(c byte, context string, cursor int64) *SyntaxError { + if c == 0 { + return &SyntaxError{ + msg: fmt.Sprintf("json: invalid character as %s", context), + Offset: cursor, + } + } + return &SyntaxError{ + msg: fmt.Sprintf("json: invalid character %c as %s", c, context), + Offset: cursor, + } +} + +func ErrInvalidBeginningOfValue(c byte, cursor int64) *SyntaxError { + return &SyntaxError{ + msg: fmt.Sprintf("invalid character '%c' looking for beginning of value", c), + Offset: cursor, + } +} + +type PathError struct { + msg string +} + +func (e *PathError) Error() string { + return fmt.Sprintf("json: invalid path format: %s", e.msg) +} + +func ErrInvalidPath(msg string, args ...interface{}) *PathError { + if len(args) != 0 { + return &PathError{msg: fmt.Sprintf(msg, args...)} + } + return &PathError{msg: msg} +} + +func ErrEmptyPath() *PathError { + return &PathError{msg: "path is empty"} +} diff --git a/vendor/github.com/goccy/go-json/internal/runtime/rtype.go b/vendor/github.com/goccy/go-json/internal/runtime/rtype.go new file mode 100644 index 00000000..37cfe35a --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/runtime/rtype.go @@ -0,0 +1,262 @@ +package runtime + +import ( + "reflect" + "unsafe" +) + +// Type representing reflect.rtype for noescape trick +type Type struct{} + +//go:linkname rtype_Align reflect.(*rtype).Align +//go:noescape +func rtype_Align(*Type) int + +func (t *Type) Align() int { + return rtype_Align(t) +} + +//go:linkname rtype_FieldAlign reflect.(*rtype).FieldAlign +//go:noescape +func rtype_FieldAlign(*Type) int + +func (t *Type) FieldAlign() int { + return rtype_FieldAlign(t) +} + +//go:linkname rtype_Method reflect.(*rtype).Method +//go:noescape +func rtype_Method(*Type, int) reflect.Method + +func (t *Type) Method(a0 int) reflect.Method { + return rtype_Method(t, a0) +} + +//go:linkname rtype_MethodByName reflect.(*rtype).MethodByName +//go:noescape +func rtype_MethodByName(*Type, string) (reflect.Method, bool) + +func (t *Type) MethodByName(a0 string) (reflect.Method, bool) { + return rtype_MethodByName(t, a0) +} + +//go:linkname rtype_NumMethod reflect.(*rtype).NumMethod +//go:noescape +func rtype_NumMethod(*Type) int + +func (t *Type) NumMethod() int { + return rtype_NumMethod(t) +} + +//go:linkname rtype_Name reflect.(*rtype).Name +//go:noescape +func rtype_Name(*Type) string + +func (t *Type) Name() string { + return rtype_Name(t) +} + +//go:linkname rtype_PkgPath reflect.(*rtype).PkgPath +//go:noescape +func rtype_PkgPath(*Type) string + +func (t *Type) PkgPath() string { + return rtype_PkgPath(t) +} + +//go:linkname rtype_Size reflect.(*rtype).Size +//go:noescape +func rtype_Size(*Type) uintptr + +func (t *Type) Size() uintptr { + return rtype_Size(t) +} + +//go:linkname rtype_String reflect.(*rtype).String +//go:noescape +func rtype_String(*Type) string + +func (t *Type) String() string { + return rtype_String(t) +} + +//go:linkname rtype_Kind reflect.(*rtype).Kind +//go:noescape +func rtype_Kind(*Type) reflect.Kind + +func (t *Type) Kind() reflect.Kind { + return rtype_Kind(t) +} + +//go:linkname rtype_Implements reflect.(*rtype).Implements +//go:noescape +func rtype_Implements(*Type, reflect.Type) bool + +func (t *Type) Implements(u reflect.Type) bool { + return rtype_Implements(t, u) +} + +//go:linkname rtype_AssignableTo reflect.(*rtype).AssignableTo +//go:noescape +func rtype_AssignableTo(*Type, reflect.Type) bool + +func (t *Type) AssignableTo(u reflect.Type) bool { + return rtype_AssignableTo(t, u) +} + +//go:linkname rtype_ConvertibleTo reflect.(*rtype).ConvertibleTo +//go:noescape +func rtype_ConvertibleTo(*Type, reflect.Type) bool + +func (t *Type) ConvertibleTo(u reflect.Type) bool { + return rtype_ConvertibleTo(t, u) +} + +//go:linkname rtype_Comparable reflect.(*rtype).Comparable +//go:noescape +func rtype_Comparable(*Type) bool + +func (t *Type) Comparable() bool { + return rtype_Comparable(t) +} + +//go:linkname rtype_Bits reflect.(*rtype).Bits +//go:noescape +func rtype_Bits(*Type) int + +func (t *Type) Bits() int { + return rtype_Bits(t) +} + +//go:linkname rtype_ChanDir reflect.(*rtype).ChanDir +//go:noescape +func rtype_ChanDir(*Type) reflect.ChanDir + +func (t *Type) ChanDir() reflect.ChanDir { + return rtype_ChanDir(t) +} + +//go:linkname rtype_IsVariadic reflect.(*rtype).IsVariadic +//go:noescape +func rtype_IsVariadic(*Type) bool + +func (t *Type) IsVariadic() bool { + return rtype_IsVariadic(t) +} + +//go:linkname rtype_Elem reflect.(*rtype).Elem +//go:noescape +func rtype_Elem(*Type) reflect.Type + +func (t *Type) Elem() *Type { + return Type2RType(rtype_Elem(t)) +} + +//go:linkname rtype_Field reflect.(*rtype).Field +//go:noescape +func rtype_Field(*Type, int) reflect.StructField + +func (t *Type) Field(i int) reflect.StructField { + return rtype_Field(t, i) +} + +//go:linkname rtype_FieldByIndex reflect.(*rtype).FieldByIndex +//go:noescape +func rtype_FieldByIndex(*Type, []int) reflect.StructField + +func (t *Type) FieldByIndex(index []int) reflect.StructField { + return rtype_FieldByIndex(t, index) +} + +//go:linkname rtype_FieldByName reflect.(*rtype).FieldByName +//go:noescape +func rtype_FieldByName(*Type, string) (reflect.StructField, bool) + +func (t *Type) FieldByName(name string) (reflect.StructField, bool) { + return rtype_FieldByName(t, name) +} + +//go:linkname rtype_FieldByNameFunc reflect.(*rtype).FieldByNameFunc +//go:noescape +func rtype_FieldByNameFunc(*Type, func(string) bool) (reflect.StructField, bool) + +func (t *Type) FieldByNameFunc(match func(string) bool) (reflect.StructField, bool) { + return rtype_FieldByNameFunc(t, match) +} + +//go:linkname rtype_In reflect.(*rtype).In +//go:noescape +func rtype_In(*Type, int) reflect.Type + +func (t *Type) In(i int) reflect.Type { + return rtype_In(t, i) +} + +//go:linkname rtype_Key reflect.(*rtype).Key +//go:noescape +func rtype_Key(*Type) reflect.Type + +func (t *Type) Key() *Type { + return Type2RType(rtype_Key(t)) +} + +//go:linkname rtype_Len reflect.(*rtype).Len +//go:noescape +func rtype_Len(*Type) int + +func (t *Type) Len() int { + return rtype_Len(t) +} + +//go:linkname rtype_NumField reflect.(*rtype).NumField +//go:noescape +func rtype_NumField(*Type) int + +func (t *Type) NumField() int { + return rtype_NumField(t) +} + +//go:linkname rtype_NumIn reflect.(*rtype).NumIn +//go:noescape +func rtype_NumIn(*Type) int + +func (t *Type) NumIn() int { + return rtype_NumIn(t) +} + +//go:linkname rtype_NumOut reflect.(*rtype).NumOut +//go:noescape +func rtype_NumOut(*Type) int + +func (t *Type) NumOut() int { + return rtype_NumOut(t) +} + +//go:linkname rtype_Out reflect.(*rtype).Out +//go:noescape +func rtype_Out(*Type, int) reflect.Type + +//go:linkname PtrTo reflect.(*rtype).ptrTo +//go:noescape +func PtrTo(*Type) *Type + +func (t *Type) Out(i int) reflect.Type { + return rtype_Out(t, i) +} + +//go:linkname IfaceIndir reflect.ifaceIndir +//go:noescape +func IfaceIndir(*Type) bool + +//go:linkname RType2Type reflect.toType +//go:noescape +func RType2Type(t *Type) reflect.Type + +type emptyInterface struct { + _ *Type + ptr unsafe.Pointer +} + +func Type2RType(t reflect.Type) *Type { + return (*Type)(((*emptyInterface)(unsafe.Pointer(&t))).ptr) +} diff --git a/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go b/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go new file mode 100644 index 00000000..baab0c59 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go @@ -0,0 +1,91 @@ +package runtime + +import ( + "reflect" + "strings" + "unicode" +) + +func getTag(field reflect.StructField) string { + return field.Tag.Get("json") +} + +func IsIgnoredStructField(field reflect.StructField) bool { + if field.PkgPath != "" { + if field.Anonymous { + t := field.Type + if t.Kind() == reflect.Ptr { + t = t.Elem() + } + if t.Kind() != reflect.Struct { + return true + } + } else { + // private field + return true + } + } + tag := getTag(field) + return tag == "-" +} + +type StructTag struct { + Key string + IsTaggedKey bool + IsOmitEmpty bool + IsString bool + Field reflect.StructField +} + +type StructTags []*StructTag + +func (t StructTags) ExistsKey(key string) bool { + for _, tt := range t { + if tt.Key == key { + return true + } + } + return false +} + +func isValidTag(s string) bool { + if s == "" { + return false + } + for _, c := range s { + switch { + case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): + // Backslash and quote chars are reserved, but + // otherwise any punctuation chars are allowed + // in a tag name. + case !unicode.IsLetter(c) && !unicode.IsDigit(c): + return false + } + } + return true +} + +func StructTagFromField(field reflect.StructField) *StructTag { + keyName := field.Name + tag := getTag(field) + st := &StructTag{Field: field} + opts := strings.Split(tag, ",") + if len(opts) > 0 { + if opts[0] != "" && isValidTag(opts[0]) { + keyName = opts[0] + st.IsTaggedKey = true + } + } + st.Key = keyName + if len(opts) > 1 { + for _, opt := range opts[1:] { + switch opt { + case "omitempty": + st.IsOmitEmpty = true + case "string": + st.IsString = true + } + } + } + return st +} diff --git a/vendor/github.com/goccy/go-json/internal/runtime/type.go b/vendor/github.com/goccy/go-json/internal/runtime/type.go new file mode 100644 index 00000000..4b693cb0 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/runtime/type.go @@ -0,0 +1,98 @@ +package runtime + +import ( + "reflect" + "sync" + "unsafe" +) + +type SliceHeader struct { + Data unsafe.Pointer + Len int + Cap int +} + +const ( + maxAcceptableTypeAddrRange = 1024 * 1024 * 2 // 2 Mib +) + +type TypeAddr struct { + BaseTypeAddr uintptr + MaxTypeAddr uintptr + AddrRange uintptr + AddrShift uintptr +} + +var ( + typeAddr *TypeAddr + once sync.Once +) + +//go:linkname typelinks reflect.typelinks +func typelinks() ([]unsafe.Pointer, [][]int32) + +//go:linkname rtypeOff reflect.rtypeOff +func rtypeOff(unsafe.Pointer, int32) unsafe.Pointer + +func AnalyzeTypeAddr() *TypeAddr { + once.Do(func() { + sections, offsets := typelinks() + if len(sections) != 1 { + return + } + if len(offsets) != 1 { + return + } + section := sections[0] + offset := offsets[0] + var ( + min uintptr = uintptr(^uint(0)) + max uintptr = 0 + isAligned64 = true + isAligned32 = true + ) + for i := 0; i < len(offset); i++ { + typ := (*Type)(rtypeOff(section, offset[i])) + addr := uintptr(unsafe.Pointer(typ)) + if min > addr { + min = addr + } + if max < addr { + max = addr + } + if typ.Kind() == reflect.Ptr { + addr = uintptr(unsafe.Pointer(typ.Elem())) + if min > addr { + min = addr + } + if max < addr { + max = addr + } + } + isAligned64 = isAligned64 && (addr-min)&63 == 0 + isAligned32 = isAligned32 && (addr-min)&31 == 0 + } + addrRange := max - min + if addrRange == 0 { + return + } + var addrShift uintptr + if isAligned64 { + addrShift = 6 + } else if isAligned32 { + addrShift = 5 + } + cacheSize := addrRange >> addrShift + if cacheSize > maxAcceptableTypeAddrRange { + return + } + typeAddr = &TypeAddr{ + BaseTypeAddr: min, + MaxTypeAddr: max, + AddrRange: addrRange, + AddrShift: addrShift, + } + }) + + return typeAddr +} diff --git a/vendor/github.com/goccy/go-json/json.go b/vendor/github.com/goccy/go-json/json.go new file mode 100644 index 00000000..fb18065a --- /dev/null +++ b/vendor/github.com/goccy/go-json/json.go @@ -0,0 +1,368 @@ +package json + +import ( + "bytes" + "context" + "encoding/json" + + "github.com/goccy/go-json/internal/encoder" +) + +// Marshaler is the interface implemented by types that +// can marshal themselves into valid JSON. +type Marshaler interface { + MarshalJSON() ([]byte, error) +} + +// MarshalerContext is the interface implemented by types that +// can marshal themselves into valid JSON with context.Context. +type MarshalerContext interface { + MarshalJSON(context.Context) ([]byte, error) +} + +// Unmarshaler is the interface implemented by types +// that can unmarshal a JSON description of themselves. +// The input can be assumed to be a valid encoding of +// a JSON value. UnmarshalJSON must copy the JSON data +// if it wishes to retain the data after returning. +// +// By convention, to approximate the behavior of Unmarshal itself, +// Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op. +type Unmarshaler interface { + UnmarshalJSON([]byte) error +} + +// UnmarshalerContext is the interface implemented by types +// that can unmarshal with context.Context a JSON description of themselves. +type UnmarshalerContext interface { + UnmarshalJSON(context.Context, []byte) error +} + +// Marshal returns the JSON encoding of v. +// +// Marshal traverses the value v recursively. +// If an encountered value implements the Marshaler interface +// and is not a nil pointer, Marshal calls its MarshalJSON method +// to produce JSON. If no MarshalJSON method is present but the +// value implements encoding.TextMarshaler instead, Marshal calls +// its MarshalText method and encodes the result as a JSON string. +// The nil pointer exception is not strictly necessary +// but mimics a similar, necessary exception in the behavior of +// UnmarshalJSON. +// +// Otherwise, Marshal uses the following type-dependent default encodings: +// +// Boolean values encode as JSON booleans. +// +// Floating point, integer, and Number values encode as JSON numbers. +// +// String values encode as JSON strings coerced to valid UTF-8, +// replacing invalid bytes with the Unicode replacement rune. +// The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e" +// to keep some browsers from misinterpreting JSON output as HTML. +// Ampersand "&" is also escaped to "\u0026" for the same reason. +// This escaping can be disabled using an Encoder that had SetEscapeHTML(false) +// called on it. +// +// Array and slice values encode as JSON arrays, except that +// []byte encodes as a base64-encoded string, and a nil slice +// encodes as the null JSON value. +// +// Struct values encode as JSON objects. +// Each exported struct field becomes a member of the object, using the +// field name as the object key, unless the field is omitted for one of the +// reasons given below. +// +// The encoding of each struct field can be customized by the format string +// stored under the "json" key in the struct field's tag. +// The format string gives the name of the field, possibly followed by a +// comma-separated list of options. The name may be empty in order to +// specify options without overriding the default field name. +// +// The "omitempty" option specifies that the field should be omitted +// from the encoding if the field has an empty value, defined as +// false, 0, a nil pointer, a nil interface value, and any empty array, +// slice, map, or string. +// +// As a special case, if the field tag is "-", the field is always omitted. +// Note that a field with name "-" can still be generated using the tag "-,". +// +// Examples of struct field tags and their meanings: +// +// // Field appears in JSON as key "myName". +// Field int `json:"myName"` +// +// // Field appears in JSON as key "myName" and +// // the field is omitted from the object if its value is empty, +// // as defined above. +// Field int `json:"myName,omitempty"` +// +// // Field appears in JSON as key "Field" (the default), but +// // the field is skipped if empty. +// // Note the leading comma. +// Field int `json:",omitempty"` +// +// // Field is ignored by this package. +// Field int `json:"-"` +// +// // Field appears in JSON as key "-". +// Field int `json:"-,"` +// +// The "string" option signals that a field is stored as JSON inside a +// JSON-encoded string. It applies only to fields of string, floating point, +// integer, or boolean types. This extra level of encoding is sometimes used +// when communicating with JavaScript programs: +// +// Int64String int64 `json:",string"` +// +// The key name will be used if it's a non-empty string consisting of +// only Unicode letters, digits, and ASCII punctuation except quotation +// marks, backslash, and comma. +// +// Anonymous struct fields are usually marshaled as if their inner exported fields +// were fields in the outer struct, subject to the usual Go visibility rules amended +// as described in the next paragraph. +// An anonymous struct field with a name given in its JSON tag is treated as +// having that name, rather than being anonymous. +// An anonymous struct field of interface type is treated the same as having +// that type as its name, rather than being anonymous. +// +// The Go visibility rules for struct fields are amended for JSON when +// deciding which field to marshal or unmarshal. If there are +// multiple fields at the same level, and that level is the least +// nested (and would therefore be the nesting level selected by the +// usual Go rules), the following extra rules apply: +// +// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered, +// even if there are multiple untagged fields that would otherwise conflict. +// +// 2) If there is exactly one field (tagged or not according to the first rule), that is selected. +// +// 3) Otherwise there are multiple fields, and all are ignored; no error occurs. +// +// Handling of anonymous struct fields is new in Go 1.1. +// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of +// an anonymous struct field in both current and earlier versions, give the field +// a JSON tag of "-". +// +// Map values encode as JSON objects. The map's key type must either be a +// string, an integer type, or implement encoding.TextMarshaler. The map keys +// are sorted and used as JSON object keys by applying the following rules, +// subject to the UTF-8 coercion described for string values above: +// - string keys are used directly +// - encoding.TextMarshalers are marshaled +// - integer keys are converted to strings +// +// Pointer values encode as the value pointed to. +// A nil pointer encodes as the null JSON value. +// +// Interface values encode as the value contained in the interface. +// A nil interface value encodes as the null JSON value. +// +// Channel, complex, and function values cannot be encoded in JSON. +// Attempting to encode such a value causes Marshal to return +// an UnsupportedTypeError. +// +// JSON cannot represent cyclic data structures and Marshal does not +// handle them. Passing cyclic structures to Marshal will result in +// an infinite recursion. +func Marshal(v interface{}) ([]byte, error) { + return MarshalWithOption(v) +} + +// MarshalNoEscape returns the JSON encoding of v and doesn't escape v. +func MarshalNoEscape(v interface{}) ([]byte, error) { + return marshalNoEscape(v) +} + +// MarshalContext returns the JSON encoding of v with context.Context and EncodeOption. +func MarshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) { + return marshalContext(ctx, v, optFuncs...) +} + +// MarshalWithOption returns the JSON encoding of v with EncodeOption. +func MarshalWithOption(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) { + return marshal(v, optFuncs...) +} + +// MarshalIndent is like Marshal but applies Indent to format the output. +// Each JSON element in the output will begin on a new line beginning with prefix +// followed by one or more copies of indent according to the indentation nesting. +func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { + return MarshalIndentWithOption(v, prefix, indent) +} + +// MarshalIndentWithOption is like Marshal but applies Indent to format the output with EncodeOption. +func MarshalIndentWithOption(v interface{}, prefix, indent string, optFuncs ...EncodeOptionFunc) ([]byte, error) { + return marshalIndent(v, prefix, indent, optFuncs...) +} + +// Unmarshal parses the JSON-encoded data and stores the result +// in the value pointed to by v. If v is nil or not a pointer, +// Unmarshal returns an InvalidUnmarshalError. +// +// Unmarshal uses the inverse of the encodings that +// Marshal uses, allocating maps, slices, and pointers as necessary, +// with the following additional rules: +// +// To unmarshal JSON into a pointer, Unmarshal first handles the case of +// the JSON being the JSON literal null. In that case, Unmarshal sets +// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into +// the value pointed at by the pointer. If the pointer is nil, Unmarshal +// allocates a new value for it to point to. +// +// To unmarshal JSON into a value implementing the Unmarshaler interface, +// Unmarshal calls that value's UnmarshalJSON method, including +// when the input is a JSON null. +// Otherwise, if the value implements encoding.TextUnmarshaler +// and the input is a JSON quoted string, Unmarshal calls that value's +// UnmarshalText method with the unquoted form of the string. +// +// To unmarshal JSON into a struct, Unmarshal matches incoming object +// keys to the keys used by Marshal (either the struct field name or its tag), +// preferring an exact match but also accepting a case-insensitive match. By +// default, object keys which don't have a corresponding struct field are +// ignored (see Decoder.DisallowUnknownFields for an alternative). +// +// To unmarshal JSON into an interface value, +// Unmarshal stores one of these in the interface value: +// +// bool, for JSON booleans +// float64, for JSON numbers +// string, for JSON strings +// []interface{}, for JSON arrays +// map[string]interface{}, for JSON objects +// nil for JSON null +// +// To unmarshal a JSON array into a slice, Unmarshal resets the slice length +// to zero and then appends each element to the slice. +// As a special case, to unmarshal an empty JSON array into a slice, +// Unmarshal replaces the slice with a new empty slice. +// +// To unmarshal a JSON array into a Go array, Unmarshal decodes +// JSON array elements into corresponding Go array elements. +// If the Go array is smaller than the JSON array, +// the additional JSON array elements are discarded. +// If the JSON array is smaller than the Go array, +// the additional Go array elements are set to zero values. +// +// To unmarshal a JSON object into a map, Unmarshal first establishes a map to +// use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal +// reuses the existing map, keeping existing entries. Unmarshal then stores +// key-value pairs from the JSON object into the map. The map's key type must +// either be any string type, an integer, implement json.Unmarshaler, or +// implement encoding.TextUnmarshaler. +// +// If a JSON value is not appropriate for a given target type, +// or if a JSON number overflows the target type, Unmarshal +// skips that field and completes the unmarshaling as best it can. +// If no more serious errors are encountered, Unmarshal returns +// an UnmarshalTypeError describing the earliest such error. In any +// case, it's not guaranteed that all the remaining fields following +// the problematic one will be unmarshaled into the target object. +// +// The JSON null value unmarshals into an interface, map, pointer, or slice +// by setting that Go value to nil. Because null is often used in JSON to mean +// “not present,” unmarshaling a JSON null into any other Go type has no effect +// on the value and produces no error. +// +// When unmarshaling quoted strings, invalid UTF-8 or +// invalid UTF-16 surrogate pairs are not treated as an error. +// Instead, they are replaced by the Unicode replacement +// character U+FFFD. +func Unmarshal(data []byte, v interface{}) error { + return unmarshal(data, v) +} + +// UnmarshalContext parses the JSON-encoded data and stores the result +// in the value pointed to by v. If you implement the UnmarshalerContext interface, +// call it with ctx as an argument. +func UnmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + return unmarshalContext(ctx, data, v) +} + +func UnmarshalWithOption(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + return unmarshal(data, v, optFuncs...) +} + +func UnmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error { + return unmarshalNoEscape(data, v, optFuncs...) +} + +// A Token holds a value of one of these types: +// +// Delim, for the four JSON delimiters [ ] { } +// bool, for JSON booleans +// float64, for JSON numbers +// Number, for JSON numbers +// string, for JSON string literals +// nil, for JSON null +type Token = json.Token + +// A Number represents a JSON number literal. +type Number = json.Number + +// RawMessage is a raw encoded JSON value. +// It implements Marshaler and Unmarshaler and can +// be used to delay JSON decoding or precompute a JSON encoding. +type RawMessage = json.RawMessage + +// A Delim is a JSON array or object delimiter, one of [ ] { or }. +type Delim = json.Delim + +// Compact appends to dst the JSON-encoded src with +// insignificant space characters elided. +func Compact(dst *bytes.Buffer, src []byte) error { + return encoder.Compact(dst, src, false) +} + +// Indent appends to dst an indented form of the JSON-encoded src. +// Each element in a JSON object or array begins on a new, +// indented line beginning with prefix followed by one or more +// copies of indent according to the indentation nesting. +// The data appended to dst does not begin with the prefix nor +// any indentation, to make it easier to embed inside other formatted JSON data. +// Although leading space characters (space, tab, carriage return, newline) +// at the beginning of src are dropped, trailing space characters +// at the end of src are preserved and copied to dst. +// For example, if src has no trailing spaces, neither will dst; +// if src ends in a trailing newline, so will dst. +func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error { + return encoder.Indent(dst, src, prefix, indent) +} + +// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 +// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 +// so that the JSON will be safe to embed inside HTML